#include "stdafx.h"
#include "qe3.h"
#include "DialogInfo.h"
#include "assert.h"
Include dependency graph for terrain.cpp:
Go to the source code of this file.
|
|
Definition at line 55 of file terrain.cpp. |
|
|
Definition at line 1551 of file terrain.cpp. |
|
|
Definition at line 52 of file terrain.cpp. |
|
||||||||||||
|
Definition at line 277 of file terrain.cpp. References active_brushes, b, Brush_AddToList(), Brush_Build(), Brush_Create(), brush_s::brush_faces, brush_t, Entity_LinkBrush(), f, face_t, j, face_s::next, pm, brush_s::pTerrain, Terrain_CalcBounds(), Terrain_CalcNormals(), brush_s::terrainBrush, face_s::texdef, vec3_t, and world_entity. Referenced by Terrain_BrushToMesh(), Terrain_Duplicate(), and Terrain_Parse(). 00277 {
00278 int j;
00279 vec3_t vMin;
00280 vec3_t vMax;
00281 brush_t *b;
00282 face_t *f;
00283
00284 // calculate the face normals
00285 Terrain_CalcNormals( pm );
00286
00287 // find the farthest points in x,y,z
00288 Terrain_CalcBounds( pm, vMin, vMax );
00289
00290 for( j = 0; j < 3; j++ ) {
00291 if ( vMin[ j ] == vMax[ j ] ) {
00292 vMin[ j ] -= 4;
00293 vMax[ j ] += 4;
00294 }
00295 }
00296
00297 b = Brush_Create( vMin, vMax, &pm->heightmap->tri.texdef );
00298
00299 for( f = b->brush_faces; f != NULL; f = f->next ) {
00300 // copy the texdef to the brush faces texdef
00301 f->texdef = pm->heightmap->tri.texdef;
00302 }
00303
00304 // FIXME: this entire type of linkage needs to be fixed
00305 b->pTerrain = pm;
00306 b->terrainBrush = true;
00307 pm->pSymbiot = b;
00308 pm->bSelected = false;
00309 pm->bDirty = true;
00310 pm->nListID = -1;
00311
00312 if ( bLinkToWorld ) {
00313 Brush_AddToList( b, &active_brushes );
00314 Entity_LinkBrush( world_entity, b );
00315 Brush_Build( b, true );
00316 }
00317
00318 return b;
00319 }
|
Here is the call graph for this function:
|
|
Definition at line 1291 of file terrain.cpp. References brush_t, brush_s::next, selected_brushes, and brush_s::terrainBrush. Referenced by CMainFrame::OnSelectionDragvertecies(). 01291 {
01292 brush_t *pb;
01293
01294 //if ( numselfaces || selected_brushes.next == &selected_brushes )
01295 if ( selected_brushes.next == &selected_brushes ) {
01296 return false;
01297 }
01298
01299 for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
01300 if ( pb->terrainBrush ) {
01301 return true;
01302 }
01303 }
01304
01305 return false;
01306 }
|
|
||||||||||||||||||||
|
Definition at line 615 of file terrain.cpp. References a, b, c, CrossProduct(), vec3_t, VectorNormalize(), and VectorSubtract. Referenced by Terrain_CalcNormals(). 00615 {
00616 vec3_t a1;
00617 vec3_t b1;
00618
00619 VectorSubtract( b, a, a1 );
00620 VectorNormalize( a1 );
00621
00622 VectorSubtract( c, a, b1 );
00623 VectorNormalize( b1 );
00624
00625 CrossProduct( a1, b1, o );
00626 VectorNormalize( o );
00627 }
|
Here is the call graph for this function:
|
||||||||||||||||
|
Definition at line 917 of file terrain.cpp. References active_brushes, brush_t, QEGlobals_t::d_numterrapoints, QEGlobals_t::d_select_mode, QEGlobals_t::d_terrapoints, f, g_qeglobals, h(), terrainVert_t::height, i, terrainFace_t::index, n, brush_s::next, terrainVert_t::normal, pm, brush_s::pTerrain, qglBegin, qglBindTexture, qglColor3f, qglColor4f, qglColor4fv, qglDisable, qglEnable, qglEnd, qglIsEnabled, qglPointSize, qglPushAttrib, qglShadeModel, qglTexCoord2fv, qglVertex3f, qglVertex3fv, qtexture_t, terravert_t::rgba, terrainVert_t::scale, sel_terrainpoint, terravert_t::tc, Terrain_GetTriangle(), Terrain_GetTriangles(), Terrain_PointInMoveList(), brush_s::terrainBrush, texture, qtexture_s::texture_number, terrainVert_t::tri, VectorSet, w, x, x2, terravert_t::xyz, terrainVert_t::xyz, y, y1, and y2. Referenced by Terrain_DrawCam(), and Terrain_DrawXY(). 00917 {
00918 int i;
00919 int w;
00920 int h;
00921 int x;
00922 int y;
00923 //int n;
00924 //float x1;
00925 //float y1;
00926 float scale_x;
00927 float scale_y;
00928 //vec3_t pSelectedPoints[ MAX_TERRA_POINTS ];
00929 //int nIndex;
00930 terravert_t a0;
00931 terravert_t a1;
00932 terravert_t a2;
00933 terravert_t b0;
00934 terravert_t b1;
00935 terravert_t b2;
00936 terrainVert_t *vert;
00937 qtexture_t *texture;
00938
00939 h = pm->height - 1;
00940 w = pm->width - 1;
00941
00942 scale_x = pm->scale_x;
00943 scale_y = pm->scale_y;
00944
00945 qglShadeModel (GL_SMOOTH);
00946
00947 if ( bShade ) {
00948 for( i = 0; i < pm->numtextures; i++ ) {
00949 texture = pm->textures[ i ];
00950
00951 qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
00952
00953 vert = pm->heightmap;
00954 for( y = 0; y < h; y++ ) {
00955 qglBegin( GL_TRIANGLES );
00956
00957 for( x = 0; x < w; x++, vert++ ) {
00958 Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
00959
00960 // first tri
00961 if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
00962 qglColor4fv( a0.rgba );
00963 qglTexCoord2fv( a0.tc );
00964 qglVertex3fv( a0.xyz );
00965
00966 qglColor4fv( a1.rgba );
00967 qglTexCoord2fv( a1.tc );
00968 qglVertex3fv( a1.xyz );
00969
00970 qglColor4fv( a2.rgba );
00971 qglTexCoord2fv( a2.tc );
00972 qglVertex3fv( a2.xyz );
00973 }
00974
00975 // second tri
00976 if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
00977 qglColor4fv( b0.rgba );
00978 qglTexCoord2fv( b0.tc );
00979 qglVertex3fv( b0.xyz );
00980
00981 qglColor4fv( b1.rgba );
00982 qglTexCoord2fv( b1.tc );
00983 qglVertex3fv( b1.xyz );
00984
00985 qglColor4fv( b2.rgba );
00986 qglTexCoord2fv( b2.tc );
00987 qglVertex3fv( b2.xyz );
00988 }
00989 }
00990
00991 qglEnd ();
00992 }
00993 }
00994 } else {
00995 for( i = 0; i < pm->numtextures; i++ ) {
00996 texture = pm->textures[ i ];
00997
00998 qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
00999
01000 vert = pm->heightmap;
01001 for( y = 0; y < h; y++ ) {
01002 qglBegin( GL_TRIANGLES );
01003
01004 for( x = 0; x < w; x++, vert++ ) {
01005 Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
01006
01007 // first tri
01008 if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
01009 qglColor4fv( a0.rgba );
01010 qglTexCoord2fv( a0.tc );
01011 qglVertex3fv( a0.xyz );
01012
01013 qglColor4fv( a1.rgba );
01014 qglTexCoord2fv( a1.tc );
01015 qglVertex3fv( a1.xyz );
01016
01017 qglColor4fv( a2.rgba );
01018 qglTexCoord2fv( a2.tc );
01019 qglVertex3fv( a2.xyz );
01020 }
01021
01022 // second tri
01023 if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
01024 qglColor4fv( b0.rgba );
01025 qglTexCoord2fv( b0.tc );
01026 qglVertex3fv( b0.xyz );
01027
01028 qglColor4fv( b1.rgba );
01029 qglTexCoord2fv( b1.tc );
01030 qglVertex3fv( b1.xyz );
01031
01032 qglColor4fv( b2.rgba );
01033 qglTexCoord2fv( b2.tc );
01034 qglVertex3fv( b2.xyz );
01035 }
01036 }
01037 qglEnd ();
01038 }
01039 }
01040 }
01041
01042 qglPushAttrib( GL_CURRENT_BIT );
01043
01044 bool bDisabledLighting = qglIsEnabled( GL_LIGHTING );
01045 if ( bDisabledLighting ) {
01046 qglDisable( GL_LIGHTING );
01047 }
01048
01049 #if 0
01050 terrainVert_t *currentrow;
01051 terrainVert_t *nextrow;
01052 float x2;
01053 float y2;
01054
01055 // Draw normals
01056 qglDisable( GL_TEXTURE_2D );
01057 qglDisable( GL_BLEND );
01058 qglColor3f( 1, 1, 1 );
01059 qglBegin( GL_LINES );
01060
01061 y2 = pm->origin[ 1 ];
01062 nextrow = pm->heightmap;
01063 for( y = 0; y < h; y++ ) {
01064 y1 = y2;
01065 y2 += scale_y;
01066
01067 x2 = pm->origin[ 0 ];
01068 currentrow = nextrow;
01069 nextrow = currentrow + pm->width;
01070 for( x = 0; x < w; x++ ) {
01071 x1 = x2;
01072 x2 += scale_x;
01073
01074 // normals
01075 qglVertex3f( x1, y1, pm->origin[ 2 ] + currentrow[ x ].height );
01076 qglVertex3f( x1 + currentrow[ x ].normal[ 0 ] * 16.0f, y1 + currentrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x ].height + currentrow[ x ].normal[ 2 ] * 16.0f );
01077
01078 qglVertex3f( x2, y1, pm->origin[ 2 ] + currentrow[ x + 1 ].height );
01079 qglVertex3f( x2 + currentrow[ x + 1 ].normal[ 0 ] * 16.0f, y1 + currentrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x + 1 ].height + currentrow[ x + 1 ].normal[ 2 ] * 16.0f );
01080
01081 qglVertex3f( x1, y2, pm->origin[ 2 ] + nextrow[ x ].height );
01082 qglVertex3f( x1 + nextrow[ x ].normal[ 0 ] * 16.0f, y2 + nextrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x ].height + nextrow[ x ].normal[ 2 ] * 16.0f );
01083
01084 qglVertex3f( x2, y2, pm->origin[ 2 ] + nextrow[ x + 1 ].height );
01085 qglVertex3f( x2 + nextrow[ x + 1 ].normal[ 0 ] * 16.0f, y2 + nextrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x + 1 ].height + nextrow[ x + 1 ].normal[ 2 ] * 16.0f );
01086 }
01087 }
01088
01089 qglEnd ();
01090 qglEnable( GL_TEXTURE_2D );
01091 #endif
01092
01093 #if 0
01094 if ( bPoints && ( g_qeglobals.d_select_mode == sel_terrainpoint || g_qeglobals.d_select_mode == sel_area ) ) {
01095 qglPointSize( 6 );
01096 qglDisable( GL_TEXTURE_2D );
01097 qglDisable( GL_BLEND );
01098
01099 qglBegin( GL_POINTS );
01100
01101 nIndex = 0;
01102
01103 qglColor4f( 1, 0, 1, 1 );
01104
01105 y1 = pm->origin[ 1 ];
01106 for ( y = 0; y < pm->height; y++, y1 += pm->scale_y ) {
01107 x1 = pm->origin[ 0 ];
01108 for( x = 0; x < pm->width; x++, x1 += pm->scale_x ) {
01109 // FIXME: need to not do loop lookups inside here
01110 n = Terrain_PointInMoveList( &pm->heightmap[ x + y * pm->width ] );
01111 if ( n >= 0 ) {
01112 VectorSet( pSelectedPoints[ nIndex ], x1, y1, pm->heightmap[ x + y * pm->width ].height + pm->origin[ 2 ] );
01113 nIndex++;
01114 } else {
01115 qglVertex3f( x1, y1, pm->origin[ 2 ] + pm->heightmap[ x + y * pm->width ].height );
01116 }
01117 }
01118 }
01119
01120 qglEnd();
01121
01122 qglEnable( GL_TEXTURE_2D );
01123
01124 if ( nIndex > 0 ) {
01125 qglBegin( GL_POINTS );
01126 qglColor4f( 0, 0, 1, 1 );
01127 while( nIndex-- > 0 ) {
01128 qglVertex3fv( pSelectedPoints[ nIndex ] );
01129 }
01130
01131 qglEnd();
01132 }
01133 }
01134 #endif
01135
01136 if ( g_qeglobals.d_numterrapoints && ( ( g_qeglobals.d_select_mode == sel_terrainpoint ) || ( g_qeglobals.d_select_mode == sel_terraintexture ) ) ) {
01137 #if 0
01138 qglPointSize( 6 );
01139 qglDisable( GL_TEXTURE_2D );
01140 qglDisable( GL_BLEND );
01141
01142 qglBegin( GL_POINTS );
01143
01144 qglColor4f( 1, 0, 1, 1 );
01145
01146 for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
01147 qglVertex3fv( g_qeglobals.d_terrapoints[ i ]->xyz );
01148 }
01149
01150 qglEnd();
01151
01152 qglEnable( GL_TEXTURE_2D );
01153 #endif
01154
01155 brush_t *pb;
01156 terrainMesh_t *pm;
01157
01158 pm = NULL;
01159 for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
01160 if ( pb->terrainBrush ) {
01161 pm = pb->pTerrain;
01162 break;
01163 }
01164 }
01165
01166 if ( pm ) {
01167 qglDisable( GL_TEXTURE_2D );
01168 qglBegin( GL_TRIANGLES );
01169 qglEnable( GL_BLEND );
01170
01171 qglColor4f( 0.25, 0.5, 1, 0.35 );
01172
01173 for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
01174 terravert_t a0;
01175 terravert_t a1;
01176 terravert_t a2;
01177
01178 qglColor4f( 0.25, 0.5, 1, g_qeglobals.d_terrapoints[ i ]->scale * 0.75 + 0.25 );
01179 Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2, &a0, &a1, &a2 );
01180
01181 qglVertex3fv( a0.xyz );
01182 qglVertex3fv( a1.xyz );
01183 qglVertex3fv( a2.xyz );
01184
01185 Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2 + 1, &a0, &a1, &a2 );
01186
01187 qglVertex3fv( a0.xyz );
01188 qglVertex3fv( a1.xyz );
01189 qglVertex3fv( a2.xyz );
01190 }
01191 qglEnd();
01192
01193 qglDisable( GL_BLEND );
01194 qglEnable( GL_TEXTURE_2D );
01195 }
01196 }
01197 }
|
Here is the call graph for this function:
|
||||||||||||||||
|
Definition at line 231 of file terrain.cpp. References h(), terrainVert_t::height, terrainFace_t::index, memset(), qtexture_s::name, terrainVert_t::normal, pm, qmalloc(), qtexture_t, terrainVert_t::rgba, texdef_t::SetName(), size_t, Terrain_AddTexture(), terrainFace_t::texdef, texture, terrainFace_t::texture, terrainVert_t::tri, VectorClear, VectorSet, w, and width. Referenced by Terrain_BrushToMesh(), Terrain_Duplicate(), and Terrain_Parse(). 00231 {
00232 int h;
00233 int w;
00234 terrainMesh_t *pm;
00235 size_t size;
00236 size_t heightmapsize;
00237 terrainVert_t *vert;
00238 int index;
00239
00240 heightmapsize = sizeof( terrainVert_t ) * width * height;
00241 size = sizeof( terrainMesh_t ) + heightmapsize;
00242
00243 pm = reinterpret_cast< terrainMesh_t * >( qmalloc( size ) );
00244
00245 memset( pm, 0x00, size );
00246
00247 pm->numtextures = 0;
00248 pm->width = width;
00249 pm->height = height;
00250 pm->heightmap = reinterpret_cast< terrainVert_t * >( pm + 1 );
00251
00252 if ( texture ) {
00253 Terrain_AddTexture( pm, texture );
00254 }
00255
00256 index = 0;
00257 vert = pm->heightmap;
00258 for( h = 0; h < pm->height; h++ ) {
00259 for( w = 0; w < pm->width; w++, vert++ ) {
00260 vert->tri.index = index++;
00261 vert->tri.texture = texture;
00262 if ( texture ) {
00263 vert->tri.texdef.SetName( texture->name );
00264 }
00265
00266 vert->height = 0;
00267
00268 VectorClear( vert->normal );
00269 VectorSet( vert->rgba, 1.0f, 1.0f, 1.0f );
00270 vert->rgba[ 3 ] = 1.0f;
00271 }
00272 }
00273
00274 return pm;
00275 }
|
Here is the call graph for this function:
|
|
Definition at line 1274 of file terrain.cpp. References brush_t, brush_s::next, selected_brushes, and brush_s::terrainBrush. Referenced by Drag_MouseUp(), and CMainFrame::OnSelectionDragvertecies(). 01274 {
01275 brush_t *pb;
01276
01277 //if ( numselfaces || selected_brushes.next == &selected_brushes )
01278 if ( selected_brushes.next == &selected_brushes ) {
01279 return false;
01280 }
01281
01282 for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
01283 if ( !pb->terrainBrush ) {
01284 return false;
01285 }
01286 }
01287
01288 return true;
01289 }
|
|
||||||||||||||||||||||||||||
|
Definition at line 1553 of file terrain.cpp. References CrossProduct(), DotProduct, t, v, vec3_t, and VectorSubtract. Referenced by Terrain_Ray(). 01553 {
01554 float u;
01555 float v;
01556 vec3_t edge1;
01557 vec3_t edge2;
01558 vec3_t tvec;
01559 vec3_t pvec;
01560 vec3_t qvec;
01561 float det;
01562
01563 VectorSubtract( vert2, vert1, edge1 );
01564 VectorSubtract( vert3, vert1, edge2 );
01565
01566 // begin calculating determinant - also used to calculate U parameter
01567 CrossProduct( dir, edge2, pvec );
01568
01569 // if determinant is near zero, ray lies in plane of triangle
01570 det = DotProduct( edge1, pvec );
01571 if ( det < EPSILON ) {
01572 return false;
01573 }
01574
01575 // calculate distance from vert1 to ray origin
01576 VectorSubtract( orig, vert1, tvec );
01577
01578 // calculate U parameter and test bounds
01579 u = DotProduct( tvec, pvec );
01580 if ( ( u < 0.0f ) || ( u > det ) ) {
01581 return false;
01582 }
01583
01584 // prepare to test V parameter
01585 CrossProduct( tvec, edge1, qvec );
01586
01587 // calculate V parameter and test bounds
01588 v = DotProduct( dir, qvec );
01589 if ( ( v < 0.0f ) || ( u + v > det ) ) {
01590 return false;
01591 }
01592
01593 // calculate t, scale parameters, ray intersects triangle
01594 *t = DotProduct( edge2, qvec ) / det;
01595
01596 return true;
01597 }
|
Here is the call graph for this function:
|
||||||||||||||||
|
Definition at line 1720 of file terrain.cpp. 01720 {
01721 }
|
|
||||||||||||
|
Definition at line 1672 of file terrain.cpp. References brush_t. Referenced by Select_TerrainFacesFromBrush(). 01672 {
01673 #if 0
01674 UnSelect_Brush( brush );
01675
01676 if( numselfaces < MAX_SEL_FACES ) {
01677 selfaces[numselfaces].face = NULL;
01678 selfaces[numselfaces].brush = brush;
01679 selfaces[numselfaces].terraface = terraface;
01680 numselfaces++;
01681 }
01682 #endif
01683 }
|
|
|
Definition at line 1685 of file terrain.cpp. References brush_t, h(), terrainMesh_t::heightmap, pm, brush_s::pTerrain, Select_TerrainFace(), w, x, and y. 01685 {
01686 terrainMesh_t *pm;
01687 int h;
01688 int w;
01689 int x;
01690 int y;
01691
01692 pm = brush->pTerrain;
01693 h = pm->height - 1;
01694 w = pm->width - 1;
01695
01696 for( y = 0; y < h; y++ ) {
01697 for( x = 0; x < w; x++ ) {
01698 Select_TerrainFace( brush, &brush->pTerrain->heightmap[ x + y * pm->width ].tri );
01699 }
01700 }
01701 }
|
Here is the call graph for this function:
|
||||||||||||||||
|
Definition at line 1703 of file terrain.cpp. References brush_t, texdef_t::contents, texdef_t::flags, texdef_t::name, terrainFace_t::texdef, terrainFace_t::texture, and Texture_ForName(). 01703 {
01704 int oldFlags;
01705 int oldContents;
01706
01707 oldFlags = face->texdef.flags;
01708 oldContents = face->texdef.contents;
01709
01710 face->texdef = *texdef;
01711
01712 face->texdef.flags = ( face->texdef.flags & ~SURF_KEEP ) | ( oldFlags & SURF_KEEP );
01713 face->texdef.contents = ( face->texdef.contents & ~CONTENTS_KEEP ) | ( oldContents & CONTENTS_KEEP );
01714
01715 face->texture = Texture_ForName( texdef->name );
01716
01717 //Terrain_AddTexture( face->texture );
01718 }
|
Here is the call graph for this function:
|
|
Definition at line 1308 of file terrain.cpp. References brush_s::next, brush_s::pTerrain, selected_brushes, and brush_s::terrainBrush. 01308 {
01309 if ( selected_brushes.next->terrainBrush ) {
01310 return selected_brushes.next->pTerrain;
01311 }
01312
01313 return NULL;
01314 }
|
|
||||||||||||||||||||
|
Definition at line 1385 of file terrain.cpp. References abs(), active_brushes, brush_t, cos(), crandom, QEGlobals_t::d_numterrapoints, QEGlobals_t::d_select_mode, QEGlobals_t::d_terrainBrush, QEGlobals_t::d_terrainBrushSize, QEGlobals_t::d_terrainFalloff, QEGlobals_t::d_terrainNoiseType, QEGlobals_t::d_texturewin, fabs(), g_bSameView, g_qeglobals, terrainMesh_t::height, terrainMesh_t::heightmap, M_PI, texdef_t::name, qtexture_s::name, brush_s::next, NOISE_PLUS, NOISE_PLUSMINUS, terrainMesh_t::origin, p, brush_s::pTerrain, random, terrainVert_t::scale, terrainMesh_t::scale_x, texdef_t::SetName(), sqrt(), Terrain_AddPoint(), Terrain_AddTexture(), brush_s::terrainBrush, texturewin_t::texdef, terrainFace_t::texdef, terrainFace_t::texture, Texture_ForName(), terrainVert_t::tri, v, terrainMesh_t::width, x, y, and y1. Referenced by Terrain_SelectPointByRay(). 01385 {
01386 brush_t *pb;
01387 terrainMesh_t *p;
01388 terrainVert_t *vert;
01389 int x;
01390 int y;
01391 int x1, y1;
01392 float dx, dy;
01393 float dist;
01394 float pd;
01395
01396 if ( !g_bSameView && !bMulti && !bFull ) {
01397 g_bSameView = true;
01398 return;
01399 }
01400
01401 g_qeglobals.d_numterrapoints = 0;
01402 for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
01403 //for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
01404 if ( pb->terrainBrush ) {
01405 p = pb->pTerrain;
01406
01407 x = ( v[ 0 ] - p->origin[ 0 ] ) / p->scale_x;
01408 y = ( v[ 1 ] - p->origin[ 1 ] ) / p->scale_x;
01409 if ( ( x < 0 ) || ( x >= p->width ) || ( y < 0 ) || ( y >= p->height ) ) {
01410 continue;
01411 }
01412
01413 vert = p->heightmap;
01414 for( y1 = 0; y1 < p->height; y1++ ) {
01415 for( x1 = 0; x1 < p->width; x1++, vert++ ) {
01416
01417 if ( g_qeglobals.d_terrainBrush == TERRAIN_BRUSH_CIRCLE ) {
01418 dx = x1 - x;
01419 dy = y1 - y;
01420 dist = sqrt( dx * dx + dy * dy );
01421 } else {
01422 dx = abs( x1 - x );
01423 dy = abs( y1 - y );
01424 if ( dx > dy ) {
01425 dist = dx;
01426 } else {
01427 dist = dy;
01428 }
01429 }
01430
01431 pd = dist * 2.0f / g_qeglobals.d_terrainBrushSize;
01432 if ( fabs( pd ) <= 1.0f ) {
01433 Terrain_AddPoint( p, vert );
01434
01435 if ( ( buttons & MK_LBUTTON ) && ( g_qeglobals.d_select_mode == sel_terraintexture ) ) {
01436 vert->tri.texture = Texture_ForName( g_qeglobals.d_texturewin.texdef.name );
01437 vert->tri.texdef.SetName( vert->tri.texture->name );
01438 Terrain_AddTexture( p, vert->tri.texture );
01439 continue;
01440 }
01441
01442 if ( g_qeglobals.d_terrainFalloff == TERRAIN_FALLOFF_CURVED ) {
01443 if ( g_qeglobals.d_terrainBrush == TERRAIN_BRUSH_CIRCLE ) {
01444 vert->scale = ( 0.5f + cos( pd * M_PI ) * 0.5f );
01445 } else {
01446 vert->scale = ( 0.5f + cos( dx/ g_qeglobals.d_terrainBrushSize * M_PI ) * 0.5f ) * ( 0.5f + cos( dy/ g_qeglobals.d_terrainBrushSize * M_PI ) * 0.5f ) - 0.25;
01447 }
01448 } else {
01449 vert->scale = 1.0f - pd;
01450 }
01451
01452 switch( g_qeglobals.d_terrainNoiseType ) {
01453 case NOISE_PLUS :
01454 vert->scale *= crandom();
01455 break;
01456
01457 case NOISE_PLUSMINUS :
01458 vert->scale *= random();
01459 break;
01460 }
01461 }
01462 }
01463 }
01464 }
01465 }
01466 }
|
Here is the call graph for this function:
|
||||||||||||
|
Definition at line 1518 of file terrain.cpp. References QEGlobals_t::d_numterrapoints, QEGlobals_t::d_terrapoints, and g_qeglobals. Referenced by Terrain_AddMovePoint(). 01518 {
01519 if ( g_qeglobals.d_numterrapoints < MAX_TERRA_POINTS ) {
01520 g_qeglobals.d_terrapoints[ g_qeglobals.d_numterrapoints++ ] = v;
01521 }
01522 }
|
|
||||||||||||
|
Definition at line 192 of file terrain.cpp. References i, pm, qtexture_t, texture, and Warning(). Referenced by MakeNewTerrain(), ParseTerrain(), Terrain_AddMovePoint(), Terrain_Duplicate(), Terrain_FindReplaceTexture(), Terrain_Parse(), Terrain_ReplaceQTexture(), and Terrain_SetTexture(). 00192 {
00193 int i;
00194
00195 if ( !texture ) {
00196 return;
00197 }
00198
00199 for( i = 0; i < pm->numtextures; i++ ) {
00200 if ( pm->textures[ i ] == texture ) {
00201 return;
00202 }
00203 }
00204
00205 if ( pm->numtextures >= MAX_TERRAIN_TEXTURES ) {
00206 Warning( "Too many textures on terrain" );
00207 return;
00208 }
00209
00210 pm->textures[ pm->numtextures++ ] = texture;
00211 }
|
Here is the call graph for this function:
