/* do some fixups for celshading */
ds->planar = qfalse;
ds->planeNum = -1;
+ ds->celShader = NULL; /* don't cel shade cels :P */
/* return the surface */
return ds;
//% Sys_Printf( "Failed to map axis %d onto patch\n", bestAxis );
}
- /* get lightmap sample size */
- if( ds->sampleSize <= 0 )
+ /* calculate lightmap sample size */
+ if( ds->shaderInfo->lightmapSampleSize > 0 ) /* shader value overrides every other */
+ ds->sampleSize = ds->shaderInfo->lightmapSampleSize;
+ else if( ds->sampleSize <= 0 ) /* may contain the entity asigned value */
+ ds->sampleSize = sampleSize; /* otherwise use global default */
+
+ if( ds->lightmapScale > 0.0f ) /* apply surface lightmap scaling factor */
{
- ds->sampleSize = sampleSize;
- if( ds->shaderInfo->lightmapSampleSize )
- ds->sampleSize = ds->shaderInfo->lightmapSampleSize;
- if( ds->lightmapScale > 0 )
- ds->sampleSize *= ds->lightmapScale;
- if( ds->sampleSize <= 0 )
- ds->sampleSize = 1;
- if(ds->sampleSize < minSampleSize)
- ds->sampleSize = minSampleSize;
- if( ds->sampleSize > 16384 ) /* powers of 2 are preferred */
- ds->sampleSize = 16384;
+ ds->sampleSize = ds->lightmapScale * (float)ds->sampleSize;
+ ds->lightmapScale = 0; /* applied */
}
+
+ if( ds->sampleSize < minSampleSize )
+ ds->sampleSize = minSampleSize;
+
+ if( ds->sampleSize < 1 )
+ ds->sampleSize = 1;
+
+ if( ds->sampleSize > 16384 ) /* powers of 2 are preferred */
+ ds->sampleSize = 16384;
}
}
ds->mapBrush = b;
ds->sideRef = AllocSideRef( s, NULL );
ds->fogNum = -1;
+ ds->sampleSize = b->lightmapSampleSize;
ds->lightmapScale = b->lightmapScale;
ds->numVerts = w->numpoints;
ds->verts = safe_malloc( ds->numVerts * sizeof( *ds->verts ) );
/* set cel shader */
ds->celShader = b->celShader;
+
+ /* set shade angle */
+ if( b->shadeAngleDegrees > 0.0f )
+ ds->shadeAngleDegrees = b->shadeAngleDegrees;
/* ydnar: gs mods: moved st biasing elsewhere */
return ds;
ds->shaderInfo = si;
ds->mapMesh = p;
+ ds->sampleSize = p->lightmapSampleSize;
ds->lightmapScale = p->lightmapScale; /* ydnar */
ds->patchWidth = mesh->width;
ds->patchHeight = mesh->height;
return AddReferenceToLeaf( ds, node );
}
+/*
+FilterBoxIntoTree_r() - ydnar
+filters a box from a surface into the tree
+*/
+
+int FilterBoxIntoTree_r( vec3_t mins, vec3_t maxs, mapDrawSurface_t *ds, node_t *node )
+{
+ float d, d0, d1, d2, dmin, dmax;
+ plane_t *plane;
+ int refs = 0;
+
+
+ /* is this a decision node? */
+ if( node->planenum != PLANENUM_LEAF )
+ {
+ /* classify the point in relation to the plane */
+ plane = &mapplanes[ node->planenum ];
+ d = DotProduct( mins, plane->normal ) - plane->dist;
+ d0 = (maxs[0] - mins[0]) * plane->normal[0];
+ d1 = (maxs[1] - mins[1]) * plane->normal[1];
+ d2 = (maxs[2] - mins[2]) * plane->normal[2];
+ dmax = d + (d0>0 ? d0 : 0) + (d1>0 ? d1 : 0) + (d2>0 ? d2 : 0);
+ dmin = d + (d0<0 ? d0 : 0) + (d1<0 ? d1 : 0) + (d2<0 ? d2 : 0);
+
+ /* filter by this plane */
+ refs = 0;
+ if( dmax >= -ON_EPSILON )
+ refs += FilterBoxIntoTree_r( mins, maxs, ds, node->children[ 0 ] );
+ if( dmin <= ON_EPSILON )
+ refs += FilterBoxIntoTree_r( mins, maxs, ds, node->children[ 1 ] );
+
+ /* return */
+ return refs;
+ }
+
+ /* add a reference */
+ return AddReferenceToLeaf( ds, node );
+}
/*
mesh_t src, *mesh;
winding_t *w;
-
+#if 0
/* subdivide the surface */
src.width = ds->patchWidth;
src.height = ds->patchHeight;
src.verts = ds->verts;
mesh = SubdivideMesh( src, FILTER_SUBDIVISION, 32 );
-
/* filter each quad into the tree (fixme: use new patch x-triangulation code?) */
refs = 0;
for( y = 0; y < (mesh->height - 1); y++ )
/* free the subdivided mesh and return */
FreeMesh( mesh );
+#else
+ for(y = 0; y + 2 < ds->patchHeight; y += 2)
+ for(x = 0; x + 2 < ds->patchWidth; x += 2)
+ {
+ vec3_t mins, maxs;
+ ClearBounds(mins, maxs);
+ AddPointToBounds(ds->verts[(y+0) * ds->patchWidth + (x+0)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+0) * ds->patchWidth + (x+1)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+0) * ds->patchWidth + (x+2)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+1) * ds->patchWidth + (x+0)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+1) * ds->patchWidth + (x+1)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+1) * ds->patchWidth + (x+2)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+2) * ds->patchWidth + (x+0)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+2) * ds->patchWidth + (x+1)].xyz, mins, maxs);
+ AddPointToBounds(ds->verts[(y+2) * ds->patchWidth + (x+2)].xyz, mins, maxs);
+ refs += FilterBoxIntoTree_r(mins, maxs, ds, tree->headnode);
+ }
+#endif
+
return refs;
}
numSurfacesByType[ ds->type ]++;
}
-
-
/*
EmitPatchSurface()
emits a bsp patch drawsurface
*/
-void EmitPatchSurface( mapDrawSurface_t *ds )
+void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds )
{
int i, j;
bspDrawSurface_t *out;
int surfaceFlags, contentFlags;
-
+ int forcePatchMeta;
+
+ /* vortex: _patchMeta support */
+ forcePatchMeta = IntForKey(e, "_patchMeta" );
+ if (!forcePatchMeta)
+ forcePatchMeta = IntForKey(e, "patchMeta" );
/* invert the surface if necessary */
if( ds->backSide || ds->shaderInfo->invert )
{
bspDrawVert_t *dv1, *dv2, temp;
-
/* walk the verts, flip the normal */
for( i = 0; i < ds->numVerts; i++ )
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
-
+
/* allocate a new surface */
if( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS )
Error( "MAX_MAP_DRAW_SURFS" );
ds->outputNum = numBSPDrawSurfaces;
numBSPDrawSurfaces++;
memset( out, 0, sizeof( *out ) );
-
+
/* set it up */
out->surfaceType = MST_PATCH;
if( debugSurfaces )
out->shaderNum = EmitShader( "debugsurfaces", NULL, NULL );
- else if( patchMeta )
+ else if( patchMeta || forcePatchMeta )
{
/* patch meta requires that we have nodraw patches for collision */
surfaceFlags = ds->shaderInfo->surfaceFlags;
numSurfacesByType[ ds->type ]++;
}
-
-
/*
OptimizeTriangleSurface() - ydnar
optimizes the vertex/index data in a triangle surface
creates a bsp drawsurface from arbitrary triangle surfaces
*/
-static void EmitTriangleSurface( mapDrawSurface_t *ds )
+void EmitTriangleSurface( mapDrawSurface_t *ds )
{
int i, temp;
bspDrawSurface_t *out;
-
-
+
/* invert the surface if necessary */
if( ds->backSide || ds->shaderInfo->invert )
{
ds->indexes[ i ] = ds->indexes[ i + 1 ];
ds->indexes[ i + 1 ] = temp;
}
-
+
/* walk the verts, flip the normal */
for( i = 0; i < ds->numVerts; i++ )
VectorScale( ds->verts[ i ].normal, -1.0f, ds->verts[ i ].normal );
-
+
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
-
+
/* allocate a new surface */
if( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS )
Error( "MAX_MAP_DRAW_SURFS" );
emits a bsp planar winding (brush face) drawsurface
*/
-static void EmitFaceSurface( mapDrawSurface_t *ds )
+static void EmitFaceSurface(mapDrawSurface_t *ds )
{
/* strip/fan finding was moved elsewhere */
StripFaceSurface( ds );
- EmitTriangleSurface( ds );
+ EmitTriangleSurface(ds);
}
-
/*
MakeDebugPortalSurfs_r() - ydnar
generates drawsurfaces for passable portals in the bsp
}
/* insert the model */
- InsertModel( (char *) model->model, 0, transform, NULL, ds->celShader, ds->entityNum, ds->castShadows, ds->recvShadows, 0, ds->lightmapScale );
+ InsertModel( (char *) model->model, 0, transform, NULL, ds->celShader, ds->entityNum, ds->castShadows, ds->recvShadows, 0, ds->lightmapScale, 0, 0 );
/* return to sender */
return 1;
if( refs == 0 )
refs = FilterPatchIntoTree( ds, tree );
if( refs > 0 )
- EmitPatchSurface( ds );
+ EmitPatchSurface( e, ds );
break;
/* handle triangle surfaces */
projects / xonotic / netradiant.git / blobdiff