mesh.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	mesh_t
Defines
#define	MAX_EXPANDED_AXIS   128
Functions
mesh_t *	CopyMesh (mesh_t *mesh)
void	FreeMesh (mesh_t *m)
void	InvertMesh (mesh_t *m)
void	MakeMeshNormals (mesh_t in)
void	MakeNormalVectors (vec3_t forward, vec3_t right, vec3_t up)
void	PrintMesh (mesh_t *m)
void	PutMeshOnCurve (mesh_t in)
mesh_t *	RemoveLinearMeshColumnsRows (mesh_t *in)
mesh_t *	SubdivideMesh (mesh_t in, float maxError, float minLength)
mesh_t *	SubdivideMeshQuads (mesh_t *in, float minLength, int maxsize, int widthtable[], int heighttable[])
mesh_t *	TransposeMesh (mesh_t *in)
Variables
int	originalHeights [MAX_EXPANDED_AXIS]
int	originalWidths [MAX_EXPANDED_AXIS]

---

Define Documentation

#define MAX_EXPANDED_AXIS   128

Definition at line 31 of file mesh.h.

---

Function Documentation

mesh_t* CopyMesh (  mesh_t *  mesh  )

Definition at line 85 of file mesh.c. References mesh_t::height, malloc(), memcpy(), mesh_t::verts, and mesh_t::width. Referenced by DrawSurfaceForMesh(), RemoveLinearMeshColumnsRows(), SubdivideMesh(), and SubdivideMeshQuads(). { mesh_t *out; int size; out = malloc( sizeof( *out ) ); out->width = mesh->width; out->height = mesh->height; size = out->width * out->height * sizeof( *out->verts ); out->verts = malloc( size ); memcpy( out->verts, mesh->verts, size ); return out; }

Here is the call graph for this function:

void FreeMesh (  mesh_t *  m  )

Definition at line 65 of file mesh.c. References free(), m, and mesh_t::verts. Referenced by AllocateLightmapForPatch(), ChopPatchByBrush(), DrawSurfaceForMesh(), FacetsForPatch(), LinearSubdivideMesh(), SplitMeshByPlane(), TraceLtm(), TransposeMesh(), VL_FacetsForPatch(), and VS_FacetsForPatch(). { free( m->verts ); free( m ); }

Here is the call graph for this function:

void InvertMesh (  mesh_t *  m  )

Definition at line 128 of file mesh.c. References h(), mesh_t::height, in, mesh_t::verts, w, and mesh_t::width. Referenced by SplitMeshByPlane(). { int w, h; drawVert_t temp; for ( h = 0 ; h < in->height ; h++ ) { for ( w = 0 ; w < in->width / 2 ; w++ ) { temp = in->verts[ h * in->width + w ]; in->verts[ h * in->width + w ] = in->verts[ h * in->width + in->width - 1 - w ]; in->verts[ h * in->width + in->width - 1 - w ] = temp; } } }

Here is the call graph for this function:

void MakeMeshNormals (  mesh_t  in  )

Definition at line 147 of file mesh.c. References count, CrossProduct(), mesh_t::height, i, in, j, k, neighbors, drawVert_t::normal, qboolean, vec3_t, VectorAdd, VectorClear, VectorCopy, VectorLength(), VectorNormalize(), VectorSubtract, mesh_t::verts, mesh_t::width, x, drawVert_t::xyz, and y. Referenced by DrawSurfaceForMesh(), FacetsForPatch(), R_GridInsertColumn(), R_GridInsertRow(), R_SubdividePatchToGrid(), TraceLtm(), VL_FacetsForPatch(), and VS_FacetsForPatch(). { int i, j, k, dist; vec3_t normal; vec3_t sum; int count; vec3_t base; vec3_t delta; int x, y; drawVert_t *dv; vec3_t around[8], temp; qboolean good[8]; qboolean wrapWidth, wrapHeight; float len; wrapWidth = qfalse; for ( i = 0 ; i < in.height ; i++ ) { VectorSubtract( in.verts[i*in.width].xyz, in.verts[i*in.width+in.width-1].xyz, delta ); len = VectorLength( delta ); if ( len > 1.0 ) { break; } } if ( i == in.height ) { wrapWidth = qtrue; } wrapHeight = qfalse; for ( i = 0 ; i < in.width ; i++ ) { VectorSubtract( in.verts[i].xyz, in.verts[i + (in.height-1)*in.width].xyz, delta ); len = VectorLength( delta ); if ( len > 1.0 ) { break; } } if ( i == in.width) { wrapHeight = qtrue; } for ( i = 0 ; i < in.width ; i++ ) { for ( j = 0 ; j < in.height ; j++ ) { count = 0; dv = &in.verts[j*in.width+i]; VectorCopy( dv->xyz, base ); for ( k = 0 ; k < 8 ; k++ ) { VectorClear( around[k] ); good[k] = qfalse; for ( dist = 1 ; dist <= 3 ; dist++ ) { x = i + neighbors[k][0] * dist; y = j + neighbors[k][1] * dist; if ( wrapWidth ) { if ( x < 0 ) { x = in.width - 1 + x; } else if ( x >= in.width ) { x = 1 + x - in.width; } } if ( wrapHeight ) { if ( y < 0 ) { y = in.height - 1 + y; } else if ( y >= in.height ) { y = 1 + y - in.height; } } if ( x < 0 || x >= in.width || y < 0 || y >= in.height ) { break; // edge of patch } VectorSubtract( in.verts[y*in.width+x].xyz, base, temp ); if ( VectorNormalize( temp, temp ) == 0 ) { continue; // degenerate edge, get more dist } else { good[k] = qtrue; VectorCopy( temp, around[k] ); break; // good edge } } } VectorClear( sum ); for ( k = 0 ; k < 8 ; k++ ) { if ( !good[k] || !good[(k+1)&7] ) { continue; // didn't get two points } CrossProduct( around[(k+1)&7], around[k], normal ); if ( VectorNormalize( normal, normal ) == 0 ) { continue; } VectorAdd( normal, sum, sum ); count++; } if ( count == 0 ) { //_printf("bad normal\n"); count = 1; } VectorNormalize( sum, dv->normal ); } } }

Here is the call graph for this function:

void MakeNormalVectors (  vec3_t  forward, vec3_t  right, vec3_t  up )

Definition at line 523 of file q_math.c. References CrossProduct(), d, DotProduct, right, up, VectorMA, and VectorNormalize(). Referenced by AddEdge(), RB_SurfaceRailRings(), and TraceLtm(). { float d; // this rotate and negate guarantees a vector // not colinear with the original right[1] = -forward[0]; right[2] = forward[1]; right[0] = forward[2]; d = DotProduct (right, forward); VectorMA (right, -d, forward, right); VectorNormalize (right); CrossProduct (right, forward, up); }

Here is the call graph for this function:

void PrintMesh (  mesh_t *  m  )

Definition at line 70 of file mesh.c. References _printf(), mesh_t::height, i, j, m, mesh_t::verts, and mesh_t::width. { int i, j; for ( i = 0 ; i < m->height ; i++ ) { for ( j = 0 ; j < m->width ; j++ ) { _printf("(%5.2f %5.2f %5.2f) " , m->verts[i*m->width+j].xyz[0] , m->verts[i*m->width+j].xyz[1] , m->verts[i*m->width+j].xyz[2] ); } _printf("\n"); } }

Here is the call graph for this function:

void PutMeshOnCurve (  mesh_t  in  )

Definition at line 257 of file mesh.c. References mesh_t::height, i, in, j, l, next, mesh_t::verts, mesh_t::width, and drawVert_t::xyz. Referenced by AllocateLightmapForPatch(), DrawSurfaceForMesh(), FacetsForPatch(), TraceLtm(), VL_FacetsForPatch(), and VS_FacetsForPatch(). { int i, j, l; float prev, next; // put all the aproximating points on the curve for ( i = 0 ; i < in.width ; i++ ) { for ( j = 1 ; j < in.height ; j += 2 ) { for ( l = 0 ; l < 3 ; l++ ) { prev = ( in.verts[j*in.width+i].xyz[l] + in.verts[(j+1)*in.width+i].xyz[l] ) * 0.5; next = ( in.verts[j*in.width+i].xyz[l] + in.verts[(j-1)*in.width+i].xyz[l] ) * 0.5; in.verts[j*in.width+i].xyz[l] = ( prev + next ) * 0.5; } } } for ( j = 0 ; j < in.height ; j++ ) { for ( i = 1 ; i < in.width ; i += 2 ) { for ( l = 0 ; l < 3 ; l++ ) { prev = ( in.verts[j*in.width+i].xyz[l] + in.verts[j*in.width+i+1].xyz[l] ) * 0.5; next = ( in.verts[j*in.width+i].xyz[l] + in.verts[j*in.width+i-1].xyz[l] ) * 0.5; in.verts[j*in.width+i].xyz[l] = ( prev + next ) * 0.5; } } } }

mesh_t* RemoveLinearMeshColumnsRows (  mesh_t *  in  )

Definition at line 467 of file mesh.c. References CopyMesh(), expand(), mesh_t::height, i, in, j, k, memmove(), originalHeights, originalWidths, ProjectPointOntoVector(), vec3_t, VectorLength(), VectorSubtract, mesh_t::verts, and mesh_t::width. Referenced by AllocateLightmapForPatch(), FacetsForPatch(), TraceLtm(), VL_FacetsForPatch(), and VS_FacetsForPatch(). { int i, j, k; float len, maxLength; vec3_t proj, dir; mesh_t out; drawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS]; out.width = in->width; out.height = in->height; for ( i = 0 ; i < in->width ; i++ ) { for ( j = 0 ; j < in->height ; j++ ) { expand[j][i] = in->verts[j*in->width+i]; } } for ( j = 1 ; j < out.width - 1; j++ ) { maxLength = 0; for ( i = 0 ; i < out.height ; i++ ) { ProjectPointOntoVector(expand[i][j].xyz, expand[i][j-1].xyz, expand[i][j+1].xyz, proj); VectorSubtract(expand[i][j].xyz, proj, dir); len = VectorLength(dir); if (len > maxLength) { maxLength = len; } } if (maxLength < 0.1) { out.width--; for ( i = 0 ; i < out.height ; i++ ) { for (k = j; k < out.width; k++) { expand[i][k] = expand[i][k+1]; } } for (k = j; k < out.width; k++) { originalWidths[k] = originalWidths[k+1]; } j--; } } for ( j = 1 ; j < out.height - 1; j++ ) { maxLength = 0; for ( i = 0 ; i < out.width ; i++ ) { ProjectPointOntoVector(expand[j][i].xyz, expand[j-1][i].xyz, expand[j+1][i].xyz, proj); VectorSubtract(expand[j][i].xyz, proj, dir); len = VectorLength(dir); if (len > maxLength) { maxLength = len; } } if (maxLength < 0.1) { out.height--; for ( i = 0 ; i < out.width ; i++ ) { for (k = j; k < out.height; k++) { expand[k][i] = expand[k+1][i]; } } for (k = j; k < out.height; k++) { originalHeights[k] = originalHeights[k+1]; } j--; } } // collapse the verts out.verts = &expand[0][0]; for ( i = 1 ; i < out.height ; i++ ) { memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(drawVert_t) ); } return CopyMesh(&out); }

Here is the call graph for this function:

mesh_t* SubdivideMesh (  mesh_t  in, float  maxError, float  minLength )

Definition at line 290 of file mesh.c. { int i, j, k, l; drawVert_t prev, next, mid; vec3_t prevxyz, nextxyz, midxyz; vec3_t delta; float len; mesh_t out; drawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS]; out.width = in.width; out.height = in.height; for ( i = 0 ; i < in.width ; i++ ) { for ( j = 0 ; j < in.height ; j++ ) { expand[j][i] = in.verts[j*in.width+i]; } } for ( i = 0 ; i < in.height ; i++ ) { originalHeights[i] = i; } for ( i = 0 ; i < in.width ; i++ ) { originalWidths[i] = i; } // horizontal subdivisions for ( j = 0 ; j + 2 < out.width ; j += 2 ) { // check subdivided midpoints against control points for ( i = 0 ; i < out.height ; i++ ) { for ( l = 0 ; l < 3 ; l++ ) { prevxyz[l] = expand[i][j+1].xyz[l] - expand[i][j].xyz[l]; nextxyz[l] = expand[i][j+2].xyz[l] - expand[i][j+1].xyz[l]; midxyz[l] = (expand[i][j].xyz[l] + expand[i][j+1].xyz[l] * 2 + expand[i][j+2].xyz[l] ) * 0.25; } // if the span length is too long, force a subdivision if ( VectorLength( prevxyz ) > minLength || VectorLength( nextxyz ) > minLength ) { break; } // see if this midpoint is off far enough to subdivide VectorSubtract( expand[i][j+1].xyz, midxyz, delta ); len = VectorLength( delta ); if ( len > maxError ) { break; } } if ( out.width + 2 >= MAX_EXPANDED_AXIS ) { break; // can't subdivide any more } if ( i == out.height ) { continue; // didn't need subdivision } // insert two columns and replace the peak out.width += 2; for ( k = out.width - 1 ; k > j + 3 ; k-- ) { originalWidths[k] = originalWidths[k-2]; } originalWidths[j+3] = originalWidths[j+1]; originalWidths[j+2] = originalWidths[j+1]; originalWidths[j+1] = originalWidths[j]; for ( i = 0 ; i < out.height ; i++ ) { LerpDrawVert( &expand[i][j], &expand[i][j+1], &prev ); LerpDrawVert( &expand[i][j+1], &expand[i][j+2], &next ); LerpDrawVert( &prev, &next, &mid ); for ( k = out.width - 1 ; k > j + 3 ; k-- ) { expand[i][k] = expand[i][k-2]; } expand[i][j + 1] = prev; expand[i][j + 2] = mid; expand[i][j + 3] = next; } // back up and recheck this set again, it may need more subdivision j -= 2; } // vertical subdivisions for ( j = 0 ; j + 2 < out.height ; j += 2 ) { // check subdivided midpoints against control points for ( i = 0 ; i < out.width ; i++ ) { for ( l = 0 ; l < 3 ; l++ ) { prevxyz[l] = expand[j+1][i].xyz[l] - expand[j][i].xyz[l]; nextxyz[l] = expand[j+2][i].xyz[l] - expand[j+1][i].xyz[l]; midxyz[l] = (expand[j][i].xyz[l] + expand[j+1][i].xyz[l] * 2 + expand[j+2][i].xyz[l] ) * 0.25; } // if the span length is too long, force a subdivision if ( VectorLength( prevxyz ) > minLength || VectorLength( nextxyz ) > minLength ) { break; } // see if this midpoint is off far enough to subdivide VectorSubtract( expand[j+1][i].xyz, midxyz, delta ); len = VectorLength( delta ); if ( len > maxError ) { break; } } if ( out.height + 2 >= MAX_EXPANDED_AXIS ) { break; // can't subdivide any more } if ( i == out.width ) { continue; // didn't need subdivision } // insert two columns and replace the peak out.height += 2; for ( k = out.height - 1 ; k > j + 3 ; k-- ) { originalHeights[k] = originalHeights[k-2]; } originalHeights[j+3] = originalHeights[j+1]; originalHeights[j+2] = originalHeights[j+1]; originalHeights[j+1] = originalHeights[j]; for ( i = 0 ; i < out.width ; i++ ) { LerpDrawVert( &expand[j][i], &expand[j+1][i], &prev ); LerpDrawVert( &expand[j+1][i], &expand[j+2][i], &next ); LerpDrawVert( &prev, &next, &mid ); for ( k = out.height - 1 ; k > j + 3 ; k-- ) { expand[k][i] = expand[k-2][i]; } expand[j+1][i] = prev; expand[j+2][i] = mid; expand[j+3][i] = next; } // back up and recheck this set again, it may need more subdivision j -= 2; } // collapse the verts out.verts = &expand[0][0]; for ( i = 1 ; i < out.height ; i++ ) { memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(drawVert_t) ); } return CopyMesh(&out); }

mesh_t* SubdivideMeshQuads (  mesh_t *  in, float  minLength, int  maxsize, int  widthtable[], int  heighttable[] )

Definition at line 572 of file mesh.c. References CopyMesh(), Error(), expand(), h(), mesh_t::height, i, in, j, k, length(), LerpDrawVertAmount(), memmove(), originalHeights, originalWidths, vec3_t, VectorLength(), VectorSubtract, mesh_t::verts, w, and mesh_t::width. Referenced by AllocateLightmapForPatch(), TraceLtm(), VL_FacetsForPatch(), and VS_FacetsForPatch(). { int i, j, k, w, h, maxsubdivisions, subdivisions; vec3_t dir; float length, maxLength, amount; mesh_t out; drawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS]; out.width = in->width; out.height = in->height; for ( i = 0 ; i < in->width ; i++ ) { for ( j = 0 ; j < in->height ; j++ ) { expand[j][i] = in->verts[j*in->width+i]; } } if (maxsize > MAX_EXPANDED_AXIS) Error("SubdivideMeshQuads: maxsize > MAX_EXPANDED_AXIS"); // horizontal subdivisions maxsubdivisions = (maxsize - in->width) / (in->width - 1); for ( w = 0, j = 0 ; w < in->width - 1; w++, j += subdivisions + 1) { maxLength = 0; for ( i = 0 ; i < out.height ; i++ ) { VectorSubtract(expand[i][j+1].xyz, expand[i][j].xyz, dir); length = VectorLength( dir ); if (length > maxLength) { maxLength = length; } } subdivisions = (int) (maxLength / minLength); if (subdivisions > maxsubdivisions) subdivisions = maxsubdivisions; widthtable[w] = subdivisions + 1; if (subdivisions <= 0) continue; out.width += subdivisions; for ( k = out.width - 1; k >= j + subdivisions; k-- ) { originalWidths[k] = originalWidths[k-subdivisions]; } for (k = 1; k <= subdivisions; k++) { originalWidths[j+k] = originalWidths[j]; } for ( i = 0 ; i < out.height ; i++ ) { for ( k = out.width - 1 ; k > j + subdivisions; k-- ) { expand[i][k] = expand[i][k-subdivisions]; } for (k = 1; k <= subdivisions; k++) { amount = (float) k / (subdivisions + 1); LerpDrawVertAmount(&expand[i][j], &expand[i][j+subdivisions+1], amount, &expand[i][j+k]); } } } maxsubdivisions = (maxsize - in->height) / (in->height - 1); for ( h = 0, j = 0 ; h < in->height - 1; h++, j += subdivisions + 1) { maxLength = 0; for ( i = 0 ; i < out.width ; i++ ) { VectorSubtract(expand[j+1][i].xyz, expand[j][i].xyz, dir); length = VectorLength( dir ); if (length > maxLength) { maxLength = length; } } subdivisions = (int) (maxLength / minLength); if (subdivisions > maxsubdivisions) subdivisions = maxsubdivisions; heighttable[h] = subdivisions + 1; if (subdivisions <= 0) continue; out.height += subdivisions; for ( k = out.height - 1; k >= j + subdivisions; k-- ) { originalHeights[k] = originalHeights[k-subdivisions]; } for (k = 1; k <= subdivisions; k++) { originalHeights[j+k] = originalHeights[j]; } for ( i = 0 ; i < out.width ; i++ ) { for ( k = out.height - 1 ; k > j + subdivisions; k-- ) { expand[k][i] = expand[k-subdivisions][i]; } for (k = 1; k <= subdivisions; k++) { amount = (float) k / (subdivisions + 1); LerpDrawVertAmount(&expand[j][i], &expand[j+subdivisions+1][i], amount, &expand[j+k][i]); } } } // collapse the verts out.verts = &expand[0][0]; for ( i = 1 ; i < out.height ; i++ ) { memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(drawVert_t) ); } return CopyMesh(&out); }

Here is the call graph for this function:

mesh_t* TransposeMesh (  mesh_t *  in  )

Definition at line 108 of file mesh.c. References FreeMesh(), h(), mesh_t::height, in, malloc(), mesh_t::verts, w, and mesh_t::width. Referenced by SplitMeshByPlane(), and TraceLtm(). { int w, h; mesh_t *out; out = malloc( sizeof( *out ) ); out->width = in->height; out->height = in->width; out->verts = malloc( out->width * out->height * sizeof( drawVert_t ) ); for ( h = 0 ; h < in->height ; h++ ) { for ( w = 0 ; w < in->width ; w++ ) { out->verts[ w * in->height + h ] = in->verts[ h * in->width + w ]; } } FreeMesh( in ); return out; }

Here is the call graph for this function:

---

Variable Documentation

int originalHeights[MAX_EXPANDED_AXIS]

Definition at line 36 of file mesh.c. Referenced by AllocateLightmapForPatch(), RemoveLinearMeshColumnsRows(), SubdivideMesh(), and SubdivideMeshQuads().

int originalWidths[MAX_EXPANDED_AXIS]

Definition at line 35 of file mesh.c. Referenced by AllocateLightmapForPatch(), RemoveLinearMeshColumnsRows(), SubdivideMesh(), and SubdivideMeshQuads().

---