Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-05-06 19:01:04 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/renderer_gl3/tr_curve.c

1013 lines
24 KiB
C
Raw Normal View History

Hard reset
2016-03-27 11:49:47 +02:00
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2006-2008 Robert Beckebans <trebor_7@users.sourceforge.net>
This file is part of XreaL source code.
XreaL source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
XreaL source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with XreaL source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// tr_curve.c
#include "tr_local.h"
/*
======================================================================================
This file does all of the processing necessary to turn a raw grid of points
read from the map file into a srfGridMesh_t ready for rendering.
The level of detail solution is direction independent, based only on subdivided
distance from the true curve.
Only a single entry point:
R_SubdividePatchToGrid(int width, int height, srfVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE])
======================================================================================
*/
/*
============
LerpDrawVert
============
*/
static void LerpSurfaceVert(srfVert_t * a, srfVert_t * b, srfVert_t * out)
{
out->xyz[0] = 0.5f * (a->xyz[0] + b->xyz[0]);
out->xyz[1] = 0.5f * (a->xyz[1] + b->xyz[1]);
out->xyz[2] = 0.5f * (a->xyz[2] + b->xyz[2]);
out->st[0] = 0.5f * (a->st[0] + b->st[0]);
out->st[1] = 0.5f * (a->st[1] + b->st[1]);
out->lightmap[0] = 0.5f * (a->lightmap[0] + b->lightmap[0]);
out->lightmap[1] = 0.5f * (a->lightmap[1] + b->lightmap[1]);
out->paintColor[0] = (a->paintColor[0] + b->paintColor[0]) * 0.5f;
out->paintColor[1] = (a->paintColor[1] + b->paintColor[1]) * 0.5f;
out->paintColor[2] = (a->paintColor[2] + b->paintColor[2]) * 0.5f;
out->paintColor[3] = (a->paintColor[3] + b->paintColor[3]) * 0.5f;
out->lightColor[0] = (a->lightColor[0] + b->lightColor[0]) * 0.5f;
out->lightColor[1] = (a->lightColor[1] + b->lightColor[1]) * 0.5f;
out->lightColor[2] = (a->lightColor[2] + b->lightColor[2]) * 0.5f;
out->lightColor[3] = (a->lightColor[3] + b->lightColor[3]) * 0.5f;
out->lightDirection[0] = (a->lightDirection[0] + b->lightDirection[0]) * 0.5f;
out->lightDirection[1] = (a->lightDirection[1] + b->lightDirection[1]) * 0.5f;
out->lightDirection[2] = (a->lightDirection[2] + b->lightDirection[2]) * 0.5f;
}
/*
============
Transpose
============
*/
static void Transpose(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE])
{
int i, j;
srfVert_t temp;
if(width > height)
{
for(i = 0; i < height; i++)
{
for(j = i + 1; j < width; j++)
{
if(j < height)
{
// swap the value
temp = ctrl[j][i];
ctrl[j][i] = ctrl[i][j];
ctrl[i][j] = temp;
}
else
{
// just copy
ctrl[j][i] = ctrl[i][j];
}
}
}
}
else
{
for(i = 0; i < width; i++)
{
for(j = i + 1; j < height; j++)
{
if(j < width)
{
// swap the value
temp = ctrl[i][j];
ctrl[i][j] = ctrl[j][i];
ctrl[j][i] = temp;
}
else
{
// just copy
ctrl[i][j] = ctrl[j][i];
}
}
}
}
}
/*
=================
MakeMeshNormals
Handles all the complicated wrapping and degenerate cases
=================
*/
static void MakeMeshNormals(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE])
{
int i, j, k, dist;
vec3_t normal;
vec3_t sum;
int count;
vec3_t base;
vec3_t delta;
int x, y;
srfVert_t *dv;
vec3_t around[8], temp;
qboolean good[8];
qboolean wrapWidth, wrapHeight;
float len;
static int neighbors[8][2] = {
{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}
};
wrapWidth = qfalse;
for(i = 0; i < height; i++)
{
VectorSubtract(ctrl[i][0].xyz, ctrl[i][width - 1].xyz, delta);
len = VectorLengthSquared(delta);
if(len > 1.0)
{
break;
}
}
if(i == height)
{
wrapWidth = qtrue;
}
wrapHeight = qfalse;
for(i = 0; i < width; i++)
{
VectorSubtract(ctrl[0][i].xyz, ctrl[height - 1][i].xyz, delta);
len = VectorLengthSquared(delta);
if(len > 1.0)
{
break;
}
}
if(i == width)
{
wrapHeight = qtrue;
}
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
count = 0;
dv = &ctrl[j][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 = width - 1 + x;
}
else if(x >= width)
{
x = 1 + x - width;
}
}
if(wrapHeight)
{
if(y < 0)
{
y = height - 1 + y;
}
else if(y >= height)
{
y = 1 + y - height;
}
}
if(x < 0 || x >= width || y < 0 || y >= height)
{
break; // edge of patch
}
VectorSubtract(ctrl[y][x].xyz, base, temp);
if(VectorNormalize2(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(VectorNormalize2(normal, normal) == 0)
{
continue;
}
VectorAdd(normal, sum, sum);
count++;
}
if(count == 0)
{
//printf("bad normal\n");
count = 1;
}
VectorNormalize2(sum, dv->normal);
}
}
}
static void MakeMeshTangentVectors(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], int numTriangles,
srfTriangle_t triangles[SHADER_MAX_TRIANGLES])
{
int i, j;
srfVert_t *dv[3];
static srfVert_t ctrl2[MAX_GRID_SIZE * MAX_GRID_SIZE];
srfTriangle_t *tri;
// FIXME: use more elegant way
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
dv[0] = &ctrl2[j * width + i];
*dv[0] = ctrl[j][i];
}
}
for(i = 0, tri = triangles; i < numTriangles; i++, tri++)
{
dv[0] = &ctrl2[tri->indexes[0]];
dv[1] = &ctrl2[tri->indexes[1]];
dv[2] = &ctrl2[tri->indexes[2]];
R_CalcTangentVectors(dv);
}
#if 0
for(i = 0; i < (width * height); i++)
{
dv0 = &ctrl2[i];
VectorNormalize(dv0->normal);
#if 0
VectorNormalize(dv0->tangent);
VectorNormalize(dv0->binormal);
#else
d = DotProduct(dv0->tangent, dv0->normal);
VectorMA(dv0->tangent, -d, dv0->normal, dv0->tangent);
VectorNormalize(dv0->tangent);
d = DotProduct(dv0->binormal, dv0->normal);
VectorMA(dv0->binormal, -d, dv0->normal, dv0->binormal);
VectorNormalize(dv0->binormal);
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for(i = 0; i < (width * height); i++)
{
for(j = 0; j < (width * height); j++)
{
if(R_CompareVert(&ctrl2[i], &ctrl2[j], qfalse))
{
VectorAdd(ctrl2[i].normal, ctrl2[j].normal, ctrl2[i].normal);
}
}
VectorNormalize(ctrl2[i].normal);
}
#endif
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
dv[0] = &ctrl2[j * width + i];
dv[1] = &ctrl[j][i];
VectorCopy(dv[0]->tangent, dv[1]->tangent);
VectorCopy(dv[0]->binormal, dv[1]->binormal);
}
}
}
static int MakeMeshTriangles(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE],
srfTriangle_t triangles[SHADER_MAX_TRIANGLES])
{
int i, j;
int numTriangles;
int w, h;
srfVert_t *dv;
static srfVert_t ctrl2[MAX_GRID_SIZE * MAX_GRID_SIZE];
h = height - 1;
w = width - 1;
numTriangles = 0;
for(i = 0; i < h; i++)
{
for(j = 0; j < w; j++)
{
int v1, v2, v3, v4;
// vertex order to be reckognized as tristrips
v1 = i * width + j + 1;
v2 = v1 - 1;
v3 = v2 + width;
v4 = v3 + 1;
triangles[numTriangles].indexes[0] = v2;
triangles[numTriangles].indexes[1] = v3;
triangles[numTriangles].indexes[2] = v1;
numTriangles++;
triangles[numTriangles].indexes[0] = v1;
triangles[numTriangles].indexes[1] = v3;
triangles[numTriangles].indexes[2] = v4;
numTriangles++;
}
}
R_CalcSurfaceTriangleNeighbors(numTriangles, triangles);
// FIXME: use more elegant way
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
dv = &ctrl2[j * width + i];
*dv = ctrl[j][i];
}
}
R_CalcSurfaceTrianglePlanes(numTriangles, triangles, ctrl2);
return numTriangles;
}
/*static void MakeTangentSpaces(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], int numTriangles,
srfTriangle_t triangles[SHADER_MAX_TRIANGLES])
{
int i, j;
float *v;
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
vec_t d;
srfVert_t *dv0, *dv1, *dv2;
srfVert_t ctrl2[MAX_GRID_SIZE * MAX_GRID_SIZE];
srfTriangle_t *tri;
// FIXME: use more elegant way
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
dv0 = &ctrl2[j * width + i];
*dv0 = ctrl[j][i];
}
}
for(i = 0; i < (width * height); i++)
{
dv0 = &ctrl2[i];
VectorClear(dv0->tangent);
VectorClear(dv0->binormal);
VectorClear(dv0->normal);
}
for(i = 0, tri = triangles; i < numTriangles; i++, tri++)
{
dv0 = &ctrl2[tri->indexes[0]];
dv1 = &ctrl2[tri->indexes[1]];
dv2 = &ctrl2[tri->indexes[2]];
v0 = dv0->xyz;
v1 = dv1->xyz;
v2 = dv2->xyz;
t0 = dv0->st;
t1 = dv1->st;
t2 = dv2->st;
R_CalcTangentSpace2(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
for(j = 0; j < 3; j++)
{
dv0 = &ctrl2[tri->indexes[j]];
v = dv0->tangent;
VectorAdd(v, tangent, v);
v = dv0->binormal;
VectorAdd(v, binormal, v);
v = dv0->normal;
VectorAdd(v, normal, v);
}
}
for(i = 0; i < (width * height); i++)
{
dv0 = &ctrl2[i];
VectorNormalize(dv0->normal);
#if 0
VectorNormalize(dv0->tangent);
VectorNormalize(dv0->binormal);
#else
d = DotProduct(dv0->tangent, dv0->normal);
VectorMA(dv0->tangent, -d, dv0->normal, dv0->tangent);
VectorNormalize(dv0->tangent);
d = DotProduct(dv0->binormal, dv0->normal);
VectorMA(dv0->binormal, -d, dv0->normal, dv0->binormal);
VectorNormalize(dv0->binormal);
#endif
}
// do another extra smoothing for normals to avoid flat shading
for(i = 0; i < (width * height); i++)
{
for(j = 0; j < (width * height); j++)
{
if(R_CompareVert(&ctrl2[i], &ctrl2[j], qfalse))
{
VectorAdd(ctrl2[i].normal, ctrl2[j].normal, ctrl2[i].normal);
}
}
VectorNormalize(ctrl2[i].normal);
}
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
dv0 = &ctrl2[j * width + i];
dv1 = &ctrl[j][i];
VectorCopy(dv0->tangent, dv1->tangent);
VectorCopy(dv0->binormal, dv1->binormal);
VectorCopy(dv0->normal, dv1->normal);
}
}
}*/
/*
============
InvertCtrl
============
*/
static void InvertCtrl(int width, int height, srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE])
{
int i, j;
srfVert_t temp;
for(i = 0; i < height; i++)
{
for(j = 0; j < width / 2; j++)
{
temp = ctrl[i][j];
ctrl[i][j] = ctrl[i][width - 1 - j];
ctrl[i][width - 1 - j] = temp;
}
}
}
/*
=================
InvertErrorTable
=================
*/
static void InvertErrorTable(float errorTable[2][MAX_GRID_SIZE], int width, int height)
{
int i;
float copy[2][MAX_GRID_SIZE];
Com_Memcpy(copy, errorTable, sizeof(copy));
for(i = 0; i < width; i++)
{
errorTable[1][i] = copy[0][i]; //[width-1-i];
}
for(i = 0; i < height; i++)
{
errorTable[0][i] = copy[1][height - 1 - i];
}
}
/*
==================
PutPointsOnCurve
==================
*/
static void PutPointsOnCurve(srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], int width, int height)
{
int i, j;
srfVert_t prev, next;
for(i = 0; i < width; i++)
{
for(j = 1; j < height; j += 2)
{
LerpSurfaceVert(&ctrl[j][i], &ctrl[j + 1][i], &prev);
LerpSurfaceVert(&ctrl[j][i], &ctrl[j - 1][i], &next);
LerpSurfaceVert(&prev, &next, &ctrl[j][i]);
}
}
for(j = 0; j < height; j++)
{
for(i = 1; i < width; i += 2)
{
LerpSurfaceVert(&ctrl[j][i], &ctrl[j][i + 1], &prev);
LerpSurfaceVert(&ctrl[j][i], &ctrl[j][i - 1], &next);
LerpSurfaceVert(&prev, &next, &ctrl[j][i]);
}
}
}
/*
=================
R_CreateSurfaceGridMesh
=================
*/
static srfGridMesh_t *R_CreateSurfaceGridMesh(int width, int height,
srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE],
float errorTable[2][MAX_GRID_SIZE],
int numTriangles, srfTriangle_t triangles[SHADER_MAX_TRIANGLES])
{
int i, j, size;
srfVert_t *vert;
vec3_t tmpVec;
srfGridMesh_t *grid;
// copy the results out to a grid
size = sizeof(*grid);
if(r_stitchCurves->integer)
{
grid = /*ri.Hunk_Alloc */ Com_Allocate(size);
Com_Memset(grid, 0, size);
grid->widthLodError = /*ri.Hunk_Alloc */ Com_Allocate(width * 4);
Com_Memcpy(grid->widthLodError, errorTable[0], width * 4);
grid->heightLodError = /*ri.Hunk_Alloc */ Com_Allocate(height * 4);
Com_Memcpy(grid->heightLodError, errorTable[1], height * 4);
grid->numTriangles = numTriangles;
grid->triangles = Com_Allocate(grid->numTriangles * sizeof(srfTriangle_t));
Com_Memcpy(grid->triangles, triangles, numTriangles * sizeof(srfTriangle_t));
grid->numVerts = (width * height);
grid->verts = Com_Allocate(grid->numVerts * sizeof(srfVert_t));
}
else
{
grid = ri.Hunk_Alloc(size, h_low);
Com_Memset(grid, 0, size);
grid->widthLodError = ri.Hunk_Alloc(width * 4, h_low);
Com_Memcpy(grid->widthLodError, errorTable[0], width * 4);
grid->heightLodError = ri.Hunk_Alloc(height * 4, h_low);
Com_Memcpy(grid->heightLodError, errorTable[1], height * 4);
grid->numTriangles = numTriangles;
grid->triangles = ri.Hunk_Alloc(grid->numTriangles * sizeof(srfTriangle_t), h_low);
Com_Memcpy(grid->triangles, triangles, numTriangles * sizeof(srfTriangle_t));
grid->numVerts = (width * height);
grid->verts = ri.Hunk_Alloc(grid->numVerts * sizeof(srfVert_t), h_low);
}
grid->width = width;
grid->height = height;
grid->surfaceType = SF_GRID;
ClearBounds(grid->bounds[0], grid->bounds[1]);
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
vert = &grid->verts[j * width + i];
*vert = ctrl[j][i];
AddPointToBounds(vert->xyz, grid->bounds[0], grid->bounds[1]);
}
}
// compute local origin and bounds
VectorAdd(grid->bounds[0], grid->bounds[1], grid->origin);
VectorScale(grid->origin, 0.5f, grid->origin);
VectorSubtract(grid->bounds[0], grid->origin, tmpVec);
grid->radius = VectorLength(tmpVec);
VectorCopy(grid->origin, grid->lodOrigin);
grid->lodRadius = grid->radius;
//
return grid;
}
/*
=================
R_FreeSurfaceGridMesh
=================
*/
void R_FreeSurfaceGridMesh(srfGridMesh_t * grid)
{
Com_Dealloc(grid->widthLodError);
Com_Dealloc(grid->heightLodError);
Com_Dealloc(grid->triangles);
Com_Dealloc(grid->verts);
Com_Dealloc(grid);
}
/*
=================
R_SubdividePatchToGrid
=================
*/
srfGridMesh_t *R_SubdividePatchToGrid(int width, int height, srfVert_t points[MAX_PATCH_SIZE * MAX_PATCH_SIZE])
{
int i, j, k, l;
srfVert_t prev, next, mid;
float len, maxLen;
int dir;
int t;
static srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
float errorTable[2][MAX_GRID_SIZE];
int numTriangles;
static srfTriangle_t triangles[SHADER_MAX_TRIANGLES];
for(i = 0; i < width; i++)
{
for(j = 0; j < height; j++)
{
ctrl[j][i] = points[j * width + i];
}
}
for(dir = 0; dir < 2; dir++)
{
for(j = 0; j < MAX_GRID_SIZE; j++)
{
errorTable[dir][j] = 0;
}
// horizontal subdivisions
for(j = 0; j + 2 < width; j += 2)
{
// check subdivided midpoints against control points
// FIXME: also check midpoints of adjacent patches against the control points
// this would basically stitch all patches in the same LOD group together.
maxLen = 0;
for(i = 0; i < height; i++)
{
vec3_t midxyz;
vec3_t midxyz2;
vec3_t dir;
vec3_t projected;
float d;
// calculate the point on the curve
for(l = 0; l < 3; l++)
{
midxyz[l] = (ctrl[i][j].xyz[l] + ctrl[i][j + 1].xyz[l] * 2 + ctrl[i][j + 2].xyz[l]) * 0.25f;
}
// see how far off the line it is
// using dist-from-line will not account for internal
// texture warping, but it gives a lot less polygons than
// dist-from-midpoint
VectorSubtract(midxyz, ctrl[i][j].xyz, midxyz);
VectorSubtract(ctrl[i][j + 2].xyz, ctrl[i][j].xyz, dir);
VectorNormalize(dir);
d = DotProduct(midxyz, dir);
VectorScale(dir, d, projected);
VectorSubtract(midxyz, projected, midxyz2);
len = VectorLengthSquared(midxyz2); // we will do the sqrt later
if(len > maxLen)
{
maxLen = len;
}
}
maxLen = sqrt(maxLen);
// if all the points are on the lines, remove the entire columns
if(maxLen < 0.1f)
{
errorTable[dir][j + 1] = 999;
continue;
}
// see if we want to insert subdivided columns
if(width + 2 > MAX_GRID_SIZE)
{
errorTable[dir][j + 1] = 1.0f / maxLen;
continue; // can't subdivide any more
}
if(maxLen <= r_subdivisions->value)
{
errorTable[dir][j + 1] = 1.0f / maxLen;
continue; // didn't need subdivision
}
errorTable[dir][j + 2] = 1.0f / maxLen;
// insert two columns and replace the peak
width += 2;
for(i = 0; i < height; i++)
{
LerpSurfaceVert(&ctrl[i][j], &ctrl[i][j + 1], &prev);
LerpSurfaceVert(&ctrl[i][j + 1], &ctrl[i][j + 2], &next);
LerpSurfaceVert(&prev, &next, &mid);
for(k = width - 1; k > j + 3; k--)
{
ctrl[i][k] = ctrl[i][k - 2];
}
ctrl[i][j + 1] = prev;
ctrl[i][j + 2] = mid;
ctrl[i][j + 3] = next;
}
// back up and recheck this set again, it may need more subdivision
j -= 2;
}
Transpose(width, height, ctrl);
t = width;
width = height;
height = t;
}
// put all the aproximating points on the curve
PutPointsOnCurve(ctrl, width, height);
// cull out any rows or columns that are colinear
for(i = 1; i < width - 1; i++)
{
if(errorTable[0][i] != 999)
{
continue;
}
for(j = i + 1; j < width; j++)
{
for(k = 0; k < height; k++)
{
ctrl[k][j - 1] = ctrl[k][j];
}
errorTable[0][j - 1] = errorTable[0][j];
}
width--;
}
for(i = 1; i < height - 1; i++)
{
if(errorTable[1][i] != 999)
{
continue;
}
for(j = i + 1; j < height; j++)
{
for(k = 0; k < width; k++)
{
ctrl[j - 1][k] = ctrl[j][k];
}
errorTable[1][j - 1] = errorTable[1][j];
}
height--;
}
#if 1
// flip for longest tristrips as an optimization
// the results should be visually identical with or
// without this step
if(height > width)
{
Transpose(width, height, ctrl);
InvertErrorTable(errorTable, width, height);
t = width;
width = height;
height = t;
InvertCtrl(width, height, ctrl);
}
#endif
// calculate triangles
numTriangles = MakeMeshTriangles(width, height, ctrl, triangles);
// calculate normals
MakeMeshNormals(width, height, ctrl);
MakeMeshTangentVectors(width, height, ctrl, numTriangles, triangles);
// calculate tangent spaces
//MakeTangentSpaces(width, height, ctrl, numTriangles, triangles);
return R_CreateSurfaceGridMesh(width, height, ctrl, errorTable, numTriangles, triangles);
}
/*
===============
R_GridInsertColumn
===============
*/
srfGridMesh_t *R_GridInsertColumn(srfGridMesh_t * grid, int column, int row, vec3_t point, float loderror)
{
int i, j;
int width, height, oldwidth;
static srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
float errorTable[2][MAX_GRID_SIZE];
float lodRadius;
vec3_t lodOrigin;
int numTriangles;
static srfTriangle_t triangles[SHADER_MAX_TRIANGLES];
oldwidth = 0;
width = grid->width + 1;
if(width > MAX_GRID_SIZE)
return NULL;
height = grid->height;
for(i = 0; i < width; i++)
{
if(i == column)
{
//insert new column
for(j = 0; j < grid->height; j++)
{
LerpSurfaceVert(&grid->verts[j * grid->width + i - 1], &grid->verts[j * grid->width + i], &ctrl[j][i]);
if(j == row)
VectorCopy(point, ctrl[j][i].xyz);
}
errorTable[0][i] = loderror;
continue;
}
errorTable[0][i] = grid->widthLodError[oldwidth];
for(j = 0; j < grid->height; j++)
{
ctrl[j][i] = grid->verts[j * grid->width + oldwidth];
}
oldwidth++;
}
for(j = 0; j < grid->height; j++)
{
errorTable[1][j] = grid->heightLodError[j];
}
// put all the aproximating points on the curve
//PutPointsOnCurve( ctrl, width, height );
// calculate triangles
numTriangles = MakeMeshTriangles(width, height, ctrl, triangles);
// calculate normals
MakeMeshNormals(width, height, ctrl);
MakeMeshTangentVectors(width, height, ctrl, numTriangles, triangles);
// calculate tangent spaces
//MakeTangentSpaces(width, height, ctrl, numTriangles, triangles);
VectorCopy(grid->lodOrigin, lodOrigin);
lodRadius = grid->lodRadius;
// free the old grid
R_FreeSurfaceGridMesh(grid);
// create a new grid
grid = R_CreateSurfaceGridMesh(width, height, ctrl, errorTable, numTriangles, triangles);
grid->lodRadius = lodRadius;
VectorCopy(lodOrigin, grid->lodOrigin);
return grid;
}
/*
===============
R_GridInsertRow
===============
*/
srfGridMesh_t *R_GridInsertRow(srfGridMesh_t * grid, int row, int column, vec3_t point, float loderror)
{
int i, j;
int width, height, oldheight;
static srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
float errorTable[2][MAX_GRID_SIZE];
float lodRadius;
vec3_t lodOrigin;
int numTriangles;
static srfTriangle_t triangles[SHADER_MAX_TRIANGLES];
oldheight = 0;
width = grid->width;
height = grid->height + 1;
if(height > MAX_GRID_SIZE)
return NULL;
for(i = 0; i < height; i++)
{
if(i == row)
{
//insert new row
for(j = 0; j < grid->width; j++)
{
LerpSurfaceVert(&grid->verts[(i - 1) * grid->width + j], &grid->verts[i * grid->width + j], &ctrl[i][j]);
if(j == column)
VectorCopy(point, ctrl[i][j].xyz);
}
errorTable[1][i] = loderror;
continue;
}
errorTable[1][i] = grid->heightLodError[oldheight];
for(j = 0; j < grid->width; j++)
{
ctrl[i][j] = grid->verts[oldheight * grid->width + j];
}
oldheight++;
}
for(j = 0; j < grid->width; j++)
{
errorTable[0][j] = grid->widthLodError[j];
}
// put all the aproximating points on the curve
//PutPointsOnCurve( ctrl, width, height );
// calculate triangles
numTriangles = MakeMeshTriangles(width, height, ctrl, triangles);
// calculate normals
MakeMeshNormals(width, height, ctrl);
MakeMeshTangentVectors(width, height, ctrl, numTriangles, triangles);
// calculate tangent spaces
//MakeTangentSpaces(width, height, ctrl, numTriangles, triangles);
VectorCopy(grid->lodOrigin, lodOrigin);
lodRadius = grid->lodRadius;
// free the old grid
R_FreeSurfaceGridMesh(grid);
// create a new grid
grid = R_CreateSurfaceGridMesh(width, height, ctrl, errorTable, numTriangles, triangles);
grid->lodRadius = lodRadius;
VectorCopy(lodOrigin, grid->lodOrigin);
return grid;
}
Reference in a new issue Copy permalink