2011-11-22 21:28:15 +00:00
|
|
|
/*
|
|
|
|
===========================================================================
|
|
|
|
|
|
|
|
Doom 3 GPL Source Code
|
2011-12-06 18:20:15 +00:00
|
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
2011-11-22 21:28:15 +00:00
|
|
|
|
2011-12-06 16:14:59 +00:00
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
2011-11-22 21:28:15 +00:00
|
|
|
|
|
|
|
Doom 3 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 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
Doom 3 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
|
|
|
|
===========================================================================
|
|
|
|
*/
|
|
|
|
|
2011-12-16 22:28:29 +00:00
|
|
|
#include "sys/platform.h"
|
|
|
|
#include "renderer/ModelManager.h"
|
|
|
|
#include "renderer/tr_local.h"
|
|
|
|
|
|
|
|
#include "tools/compilers/compiler_public.h"
|
2011-11-22 21:28:15 +00:00
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
#include <GL/gl.h>
|
|
|
|
#include <GL/glu.h>
|
2011-12-16 22:28:29 +00:00
|
|
|
#include "sys/win32/win_local.h"
|
2011-11-22 21:28:15 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
render a normalmap tga file from an ase model for bump mapping
|
|
|
|
|
|
|
|
To make ray-tracing into the high poly mesh efficient, we preconstruct
|
|
|
|
a 3D hash table of the triangles that need to be tested for a given source
|
|
|
|
point.
|
|
|
|
|
|
|
|
This task is easier than a general ray tracing optimization, because we
|
|
|
|
known that all of the triangles are going to be "near" the source point.
|
|
|
|
|
|
|
|
TraceFraction determines the maximum distance in any direction that
|
|
|
|
a trace will go. It is expressed as a fraction of the largest axis of
|
|
|
|
the bounding box, so it doesn't matter what units are used for modeling.
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAX_QPATH 256
|
|
|
|
|
|
|
|
#define DEFAULT_TRACE_FRACTION 0.05
|
|
|
|
|
|
|
|
#define INITIAL_TRI_TO_LINK_EXPANSION 16 // can grow as needed
|
|
|
|
#define HASH_AXIS_BINS 100
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int faceNum;
|
|
|
|
int nextLink;
|
|
|
|
} triLink_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int triLink;
|
|
|
|
int rayNumber; // don't need to test again if still on same ray
|
|
|
|
} binLink_t;
|
|
|
|
|
|
|
|
#define MAX_LINKS_PER_BLOCK 0x100000
|
|
|
|
#define MAX_LINK_BLOCKS 0x100
|
|
|
|
typedef struct {
|
|
|
|
idBounds bounds;
|
|
|
|
float binSize[3];
|
|
|
|
int numLinkBlocks;
|
|
|
|
triLink_t *linkBlocks[MAX_LINK_BLOCKS];
|
|
|
|
binLink_t binLinks[HASH_AXIS_BINS][HASH_AXIS_BINS][HASH_AXIS_BINS];
|
|
|
|
} triHash_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
char outputName[MAX_QPATH];
|
|
|
|
char highName[MAX_QPATH];
|
|
|
|
byte *localPic;
|
|
|
|
byte *globalPic;
|
|
|
|
byte *colorPic;
|
|
|
|
float *edgeDistances; // starts out -1 for untraced, for each texel, 0 = true interior, >0 = off-edge rasterization
|
|
|
|
int width, height;
|
|
|
|
int antiAlias;
|
|
|
|
int outline;
|
|
|
|
bool saveGlobalMap;
|
|
|
|
bool saveColorMap;
|
|
|
|
float traceFrac;
|
|
|
|
float traceDist;
|
|
|
|
srfTriangles_t *mesh; // high poly mesh
|
|
|
|
idRenderModel *highModel;
|
2011-12-06 18:20:15 +00:00
|
|
|
triHash_t *hash;
|
2011-11-22 21:28:15 +00:00
|
|
|
} renderBump_t;
|
|
|
|
|
|
|
|
static int rayNumber; // for avoiding retests of bins and faces
|
|
|
|
|
|
|
|
static int oldWidth, oldHeight;
|
|
|
|
|
|
|
|
/*
|
|
|
|
===============
|
|
|
|
SaveWindow
|
|
|
|
===============
|
|
|
|
*/
|
|
|
|
static void SaveWindow( void ) {
|
|
|
|
oldWidth = glConfig.vidWidth;
|
|
|
|
oldHeight = glConfig.vidHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
===============
|
|
|
|
ResizeWindow
|
|
|
|
===============
|
|
|
|
*/
|
|
|
|
static void ResizeWindow( int width, int height ) {
|
2019-01-07 01:42:00 +00:00
|
|
|
#if defined(WIN32) && defined(ID_ALLOW_TOOLS)
|
2011-11-22 21:28:15 +00:00
|
|
|
int winWidth, winHeight;
|
|
|
|
if ( glConfig.isFullscreen ) {
|
|
|
|
winWidth = width;
|
|
|
|
winHeight = height;
|
|
|
|
} else {
|
|
|
|
RECT r;
|
|
|
|
|
|
|
|
// adjust width and height for window border
|
|
|
|
r.bottom = height;
|
|
|
|
r.left = 0;
|
|
|
|
r.top = 0;
|
|
|
|
r.right = width;
|
|
|
|
|
|
|
|
AdjustWindowRect (&r, WINDOW_STYLE|WS_SYSMENU, FALSE);
|
|
|
|
winHeight = r.bottom - r.top;
|
|
|
|
winWidth = r.right - r.left;
|
|
|
|
|
|
|
|
}
|
|
|
|
SetWindowPos( win32.hWnd, HWND_TOP, 0, 0, winWidth, winHeight, SWP_SHOWWINDOW );
|
|
|
|
|
2019-01-07 01:42:00 +00:00
|
|
|
// FIXME: ??? qwglMakeCurrent( win32.hDC, win32.hGLRC );
|
2011-11-22 21:28:15 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
===============
|
|
|
|
RestoreWindow
|
|
|
|
===============
|
|
|
|
*/
|
|
|
|
static void RestoreWindow( void ) {
|
2019-01-07 01:42:00 +00:00
|
|
|
#if defined(WIN32) && defined(ID_ALLOW_TOOLS)
|
2011-11-22 21:28:15 +00:00
|
|
|
int winWidth, winHeight;
|
|
|
|
if ( glConfig.isFullscreen ) {
|
|
|
|
winWidth = oldWidth;
|
|
|
|
winHeight = oldHeight;
|
|
|
|
} else {
|
|
|
|
RECT r;
|
|
|
|
|
|
|
|
// adjust width and height for window border
|
|
|
|
r.bottom = oldHeight;
|
|
|
|
r.left = 0;
|
|
|
|
r.top = 0;
|
|
|
|
r.right = oldWidth;
|
|
|
|
|
|
|
|
AdjustWindowRect (&r, WINDOW_STYLE|WS_SYSMENU, FALSE);
|
|
|
|
winHeight = r.bottom - r.top;
|
|
|
|
winWidth = r.right - r.left;
|
|
|
|
}
|
|
|
|
SetWindowPos( win32.hWnd, HWND_TOP, 0, 0, winWidth, winHeight, SWP_SHOWWINDOW );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
OutlineNormalMap
|
|
|
|
|
|
|
|
Puts a single pixel border around all non-empty pixels
|
|
|
|
Does NOT copy the alpha channel, so it can be used as
|
|
|
|
an alpha test map.
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static void OutlineNormalMap( byte *data, int width, int height, int emptyR, int emptyG, int emptyB ) {
|
|
|
|
byte *orig;
|
|
|
|
int i, j, k, l;
|
|
|
|
idVec3 normal;
|
|
|
|
byte *out;
|
|
|
|
|
|
|
|
orig = (byte *)Mem_Alloc( width * height * 4 );
|
|
|
|
memcpy( orig, data, width * height * 4 );
|
|
|
|
|
|
|
|
for ( i = 0 ; i < width ; i++ ) {
|
|
|
|
for ( j = 0 ; j < height ; j++ ) {
|
|
|
|
out = data + ( j * width + i ) * 4;
|
|
|
|
if ( out[0] != emptyR || out[1] != emptyG || out[2] != emptyB ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
normal = vec3_origin;
|
|
|
|
for ( k = -1 ; k < 2 ; k++ ) {
|
|
|
|
for ( l = -1 ; l < 2 ; l++ ) {
|
|
|
|
byte *in;
|
|
|
|
|
|
|
|
in = orig + ( ((j+l)&(height-1))*width + ((i+k)&(width-1)) ) * 4;
|
|
|
|
|
|
|
|
if ( in[0] == emptyR && in[1] == emptyG && in[2] == emptyB ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
normal[0] += ( in[0] - 128 );
|
|
|
|
normal[1] += ( in[1] - 128 );
|
|
|
|
normal[2] += ( in[2] - 128 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( normal.Normalize() < 0.5 ) {
|
|
|
|
continue; // no valid samples
|
|
|
|
}
|
|
|
|
|
|
|
|
out[0] = 128 + 127 * normal[0];
|
|
|
|
out[1] = 128 + 127 * normal[1];
|
|
|
|
out[2] = 128 + 127 * normal[2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Mem_Free( orig );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
OutlineColorMap
|
|
|
|
|
|
|
|
Puts a single pixel border around all non-empty pixels
|
|
|
|
Does NOT copy the alpha channel, so it can be used as
|
|
|
|
an alpha test map.
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static void OutlineColorMap( byte *data, int width, int height, int emptyR, int emptyG, int emptyB ) {
|
|
|
|
byte *orig;
|
|
|
|
int i, j, k, l;
|
|
|
|
idVec3 normal;
|
|
|
|
byte *out;
|
|
|
|
|
|
|
|
orig = (byte *)Mem_Alloc( width * height * 4 );
|
|
|
|
memcpy( orig, data, width * height * 4 );
|
|
|
|
|
|
|
|
for ( i = 0 ; i < width ; i++ ) {
|
|
|
|
for ( j = 0 ; j < height ; j++ ) {
|
|
|
|
out = data + ( j * width + i ) * 4;
|
|
|
|
if ( out[0] != emptyR || out[1] != emptyG || out[2] != emptyB ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
normal = vec3_origin;
|
|
|
|
int count = 0;
|
|
|
|
for ( k = -1 ; k < 2 ; k++ ) {
|
|
|
|
for ( l = -1 ; l < 2 ; l++ ) {
|
|
|
|
byte *in;
|
|
|
|
|
|
|
|
in = orig + ( ((j+l)&(height-1))*width + ((i+k)&(width-1)) ) * 4;
|
|
|
|
|
|
|
|
if ( in[0] == emptyR && in[1] == emptyG && in[2] == emptyB ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
normal[0] += in[0];
|
|
|
|
normal[1] += in[1];
|
|
|
|
normal[2] += in[2];
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !count ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
normal *= (1.0 / count );
|
|
|
|
|
|
|
|
out[0] = normal[0];
|
|
|
|
out[1] = normal[1];
|
|
|
|
out[2] = normal[2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Mem_Free( orig );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
FreeTriHash
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static void FreeTriHash( triHash_t *hash ) {
|
|
|
|
for ( int i = 0 ; i < hash->numLinkBlocks ; i++ ) {
|
|
|
|
Mem_Free( hash->linkBlocks[i] );
|
|
|
|
}
|
|
|
|
Mem_Free( hash );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
CreateTriHash
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static triHash_t *CreateTriHash( const srfTriangles_t *highMesh ) {
|
|
|
|
triHash_t *hash;
|
|
|
|
int i, j, k, l;
|
|
|
|
idBounds bounds, triBounds;
|
|
|
|
int iBounds[2][3];
|
|
|
|
int maxLinks, numLinks;
|
|
|
|
|
|
|
|
hash = (triHash_t *)Mem_Alloc( sizeof( *hash ) );
|
|
|
|
memset( hash, 0, sizeof( *hash ) );
|
|
|
|
|
|
|
|
// find the bounding volume for the mesh
|
|
|
|
bounds.Clear();
|
|
|
|
for ( i = 0 ; i < highMesh->numVerts ; i++ ) {
|
|
|
|
bounds.AddPoint( highMesh->verts[i].xyz );
|
|
|
|
}
|
|
|
|
|
|
|
|
hash->bounds = bounds;
|
|
|
|
|
|
|
|
// divide each axis as needed
|
|
|
|
for ( i = 0 ; i < 3 ; i++ ) {
|
|
|
|
hash->binSize[i] = ( bounds[1][i] - bounds[0][i] ) / HASH_AXIS_BINS;
|
|
|
|
if ( hash->binSize[i] <= 0 ) {
|
|
|
|
common->FatalError( "CreateTriHash: bad bounds: (%f %f %f) to (%f %f %f)",
|
|
|
|
bounds[0][0],bounds[0][1],bounds[0][2],
|
|
|
|
bounds[1][0],bounds[1][1],bounds[1][2] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// a -1 link number terminated the link chain
|
|
|
|
memset( hash->binLinks, -1, sizeof( hash->binLinks ) );
|
|
|
|
|
|
|
|
numLinks = 0;
|
|
|
|
|
|
|
|
hash->linkBlocks[hash->numLinkBlocks] = (triLink_t *)Mem_Alloc( MAX_LINKS_PER_BLOCK * sizeof( triLink_t ) );
|
|
|
|
hash->numLinkBlocks++;
|
|
|
|
maxLinks = hash->numLinkBlocks * MAX_LINKS_PER_BLOCK;
|
|
|
|
|
|
|
|
// for each triangle, place a triLink in each bin that might reference it
|
|
|
|
for ( i = 0 ; i < highMesh->numIndexes ; i+=3 ) {
|
|
|
|
// determine which hash bins the triangle will need to be in
|
|
|
|
triBounds.Clear();
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
triBounds.AddPoint( highMesh->verts[ highMesh->indexes[i+j] ].xyz );
|
|
|
|
}
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
iBounds[0][j] = ( triBounds[0][j] - hash->bounds[0][j] ) / hash->binSize[j];
|
|
|
|
iBounds[0][j] -= 0.001; // epsilon
|
|
|
|
if ( iBounds[0][j] < 0 ) {
|
|
|
|
iBounds[0][j] = 0;
|
|
|
|
} else if ( iBounds[0][j] >= HASH_AXIS_BINS ) {
|
|
|
|
iBounds[0][j] = HASH_AXIS_BINS-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
iBounds[1][j] = ( triBounds[1][j] - hash->bounds[0][j] ) / hash->binSize[j];
|
|
|
|
iBounds[0][j] += 0.001; // epsilon
|
|
|
|
if ( iBounds[1][j] < 0 ) {
|
|
|
|
iBounds[1][j] = 0;
|
|
|
|
} else if ( iBounds[1][j] >= HASH_AXIS_BINS ) {
|
|
|
|
iBounds[1][j] = HASH_AXIS_BINS-1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// add the links
|
|
|
|
for ( j = iBounds[0][0] ; j <= iBounds[1][0] ; j++ ) {
|
|
|
|
for ( k = iBounds[0][1] ; k <= iBounds[1][1] ; k++ ) {
|
|
|
|
for ( l = iBounds[0][2] ; l <= iBounds[1][2] ; l++ ) {
|
|
|
|
if ( numLinks == maxLinks ) {
|
|
|
|
hash->linkBlocks[hash->numLinkBlocks] = (triLink_t *)Mem_Alloc( MAX_LINKS_PER_BLOCK * sizeof( triLink_t ) );
|
|
|
|
hash->numLinkBlocks++;
|
|
|
|
maxLinks = hash->numLinkBlocks * MAX_LINKS_PER_BLOCK;
|
|
|
|
}
|
|
|
|
|
|
|
|
triLink_t *link = &hash->linkBlocks[ numLinks / MAX_LINKS_PER_BLOCK ][ numLinks % MAX_LINKS_PER_BLOCK ];
|
|
|
|
link->faceNum = i / 3;
|
|
|
|
link->nextLink = hash->binLinks[j][k][l].triLink;
|
|
|
|
hash->binLinks[j][k][l].triLink = numLinks;
|
|
|
|
numLinks++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
common->Printf( "%i triangles made %i links\n", highMesh->numIndexes / 3, numLinks );
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
=================
|
|
|
|
TraceToMeshFace
|
|
|
|
|
|
|
|
Returns the distance from the point to the intersection, or DIST_NO_INTERSECTION
|
|
|
|
=================
|
|
|
|
*/
|
|
|
|
#define DIST_NO_INTERSECTION -999999999.0f
|
2011-12-06 18:20:15 +00:00
|
|
|
static float TraceToMeshFace( const srfTriangles_t *highMesh, int faceNum,
|
2011-11-22 21:28:15 +00:00
|
|
|
float minDist, float maxDist,
|
|
|
|
const idVec3 &point, const idVec3 &normal, idVec3 &sampledNormal,
|
|
|
|
byte sampledColor[4] ) {
|
|
|
|
int j;
|
|
|
|
float dist;
|
|
|
|
const idVec3 *v[3];
|
|
|
|
const idPlane *plane;
|
|
|
|
idVec3 edge;
|
|
|
|
float d;
|
|
|
|
idVec3 dir[3];
|
|
|
|
float baseArea;
|
|
|
|
float bary[3];
|
|
|
|
idVec3 testVert;
|
|
|
|
|
|
|
|
v[0] = &highMesh->verts[ highMesh->indexes[ faceNum * 3 + 0 ] ].xyz;
|
|
|
|
v[1] = &highMesh->verts[ highMesh->indexes[ faceNum * 3 + 1 ] ].xyz;
|
|
|
|
v[2] = &highMesh->verts[ highMesh->indexes[ faceNum * 3 + 2 ] ].xyz;
|
|
|
|
|
|
|
|
plane = highMesh->facePlanes + faceNum;
|
|
|
|
|
|
|
|
// only test against planes facing the same direction as our normal
|
|
|
|
d = plane->Normal() * normal;
|
|
|
|
if ( d <= 0.0001f ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
// find the point of impact on the plane
|
|
|
|
dist = plane->Distance( point );
|
|
|
|
dist /= -d;
|
|
|
|
|
|
|
|
testVert = point + dist * normal;
|
|
|
|
|
|
|
|
// if this would be beyond our requested trace distance,
|
|
|
|
// don't even check it
|
|
|
|
if ( dist > maxDist ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( dist < minDist ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if normal is inside all edge planes, this face is hit
|
|
|
|
VectorSubtract( *v[0], point, dir[0] );
|
|
|
|
VectorSubtract( *v[1], point, dir[1] );
|
|
|
|
edge = dir[0].Cross( dir[1] );
|
|
|
|
d = DotProduct( normal, edge );
|
|
|
|
if ( d > 0.0f ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
VectorSubtract( *v[2], point, dir[2] );
|
|
|
|
edge = dir[1].Cross( dir[2] );
|
|
|
|
d = DotProduct( normal, edge );
|
|
|
|
if ( d > 0.0f ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
edge = dir[2].Cross( dir[0] );
|
|
|
|
d = DotProduct( normal, edge );
|
|
|
|
if ( d > 0.0f ) {
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate barycentric coordinates of the impact point
|
|
|
|
// on the high poly triangle
|
|
|
|
bary[0] = idWinding::TriangleArea( testVert, *v[1], *v[2] );
|
|
|
|
bary[1] = idWinding::TriangleArea( *v[0], testVert, *v[2] );
|
|
|
|
bary[2] = idWinding::TriangleArea( *v[0], *v[1], testVert );
|
|
|
|
|
|
|
|
baseArea = idWinding::TriangleArea( *v[0], *v[1], *v[2] );
|
|
|
|
bary[0] /= baseArea;
|
|
|
|
bary[1] /= baseArea;
|
|
|
|
bary[2] /= baseArea;
|
|
|
|
|
|
|
|
if ( bary[0] + bary[1] + bary[2] > 1.1 ) {
|
|
|
|
bary[0] = bary[0];
|
|
|
|
return DIST_NO_INTERSECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
// triangularly interpolate the normals to the sample point
|
|
|
|
sampledNormal = vec3_origin;
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
sampledNormal += bary[j] * highMesh->verts[ highMesh->indexes[ faceNum * 3 + j ] ].normal;
|
|
|
|
}
|
|
|
|
sampledNormal.Normalize();
|
|
|
|
|
|
|
|
sampledColor[0] = sampledColor[1] = sampledColor[2] = sampledColor[3] = 0;
|
|
|
|
for ( int i = 0 ; i < 4 ; i++ ) {
|
|
|
|
float color = 0.0f;
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
color += bary[j] * highMesh->verts[ highMesh->indexes[ faceNum * 3 + j ] ].color[i];
|
|
|
|
}
|
|
|
|
sampledColor[i] = color;
|
|
|
|
}
|
|
|
|
return dist;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
SampleHighMesh
|
|
|
|
|
2011-12-06 18:20:15 +00:00
|
|
|
Find the best surface normal in the high poly mesh
|
2011-11-22 21:28:15 +00:00
|
|
|
for a ray coming from the surface of the low poly mesh
|
|
|
|
|
|
|
|
Returns false if the trace doesn't hit anything
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static bool SampleHighMesh( const renderBump_t *rb,
|
2011-12-06 18:20:15 +00:00
|
|
|
const idVec3 &point, const idVec3 &direction, idVec3 &sampledNormal,
|
2011-11-22 21:28:15 +00:00
|
|
|
byte sampledColor[4] ) {
|
|
|
|
idVec3 p;
|
|
|
|
binLink_t *bl;
|
|
|
|
int linkNum;
|
|
|
|
int faceNum;
|
|
|
|
float dist, bestDist;
|
|
|
|
int block[3];
|
|
|
|
float maxDist;
|
|
|
|
int c_hits;
|
|
|
|
int i;
|
|
|
|
idVec3 normal;
|
|
|
|
|
|
|
|
// we allow non-normalized directions on input
|
|
|
|
normal = direction;
|
|
|
|
normal.Normalize();
|
|
|
|
|
|
|
|
// increment our uniqueness counter (FIXME: make thread safe?)
|
|
|
|
rayNumber++;
|
|
|
|
|
|
|
|
// the max distance will be the traceFrac times the longest axis of the high poly model
|
|
|
|
bestDist = -rb->traceDist;
|
|
|
|
maxDist = rb->traceDist;
|
|
|
|
|
|
|
|
sampledNormal = vec3_origin;
|
|
|
|
|
|
|
|
c_hits = 0;
|
|
|
|
|
|
|
|
// this is a pretty damn lazy way to walk through a 3D grid, and has a (very slight)
|
|
|
|
// chance of missing a triangle in a corner crossing case
|
|
|
|
#define RAY_STEPS 100
|
|
|
|
for ( i = 0 ; i < RAY_STEPS ; i++ ) {
|
|
|
|
p = point - rb->hash->bounds[0] + normal * ( -1.0 + 2.0 * i / RAY_STEPS ) * rb->traceDist;
|
|
|
|
|
|
|
|
block[0] = floor( p[0] / rb->hash->binSize[0] );
|
|
|
|
block[1] = floor( p[1] / rb->hash->binSize[1] );
|
|
|
|
block[2] = floor( p[2] / rb->hash->binSize[2] );
|
|
|
|
|
|
|
|
if ( block[0] < 0 || block[0] >= HASH_AXIS_BINS ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ( block[1] < 0 || block[1] >= HASH_AXIS_BINS ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ( block[2] < 0 || block[2] >= HASH_AXIS_BINS ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: casting away const
|
|
|
|
bl = (binLink_t *)&rb->hash->binLinks[block[0]][block[1]][block[2]];
|
|
|
|
if ( bl->rayNumber == rayNumber ) {
|
|
|
|
continue; // already tested this block
|
|
|
|
}
|
|
|
|
bl->rayNumber = rayNumber;
|
|
|
|
linkNum = bl->triLink;
|
|
|
|
triLink_t *link;
|
|
|
|
for ( ; linkNum != -1 ; linkNum = link->nextLink ) {
|
|
|
|
link = &rb->hash->linkBlocks[ linkNum / MAX_LINKS_PER_BLOCK ][ linkNum % MAX_LINKS_PER_BLOCK ];
|
|
|
|
|
|
|
|
faceNum = link->faceNum;
|
2011-12-06 18:20:15 +00:00
|
|
|
dist = TraceToMeshFace( rb->mesh, faceNum,
|
2011-11-22 21:28:15 +00:00
|
|
|
bestDist, maxDist, point, normal, sampledNormal, sampledColor );
|
|
|
|
if ( dist == DIST_NO_INTERSECTION ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
c_hits++;
|
|
|
|
// continue looking for a better match
|
|
|
|
bestDist = dist;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (bool)( bestDist > -rb->traceDist );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
=============
|
|
|
|
TriTextureArea
|
|
|
|
|
|
|
|
This may be negatove
|
|
|
|
=============
|
|
|
|
*/
|
|
|
|
static float TriTextureArea( const float a[2], const float b[2], const float c[2] ) {
|
|
|
|
idVec3 d1, d2;
|
|
|
|
idVec3 cross;
|
|
|
|
float area;
|
|
|
|
|
|
|
|
d1[0] = b[0] - a[0];
|
|
|
|
d1[1] = b[1] - a[1];
|
|
|
|
d1[2] = 0;
|
|
|
|
|
|
|
|
d2[0] = c[0] - a[0];
|
|
|
|
d2[1] = c[1] - a[1];
|
|
|
|
d2[2] = 0;
|
2011-12-06 18:20:15 +00:00
|
|
|
|
2011-11-22 21:28:15 +00:00
|
|
|
cross = d1.Cross( d2 );
|
|
|
|
area = 0.5 * cross.Length();
|
|
|
|
|
|
|
|
if ( cross[2] < 0 ) {
|
|
|
|
return -area;
|
|
|
|
} else {
|
|
|
|
return area;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
RasterizeTriangle
|
|
|
|
|
|
|
|
It is ok for the texcoords to wrap around, the rasterization
|
|
|
|
will deal with it properly.
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static void RasterizeTriangle( const srfTriangles_t *lowMesh, const idVec3 *lowMeshNormals, int lowFaceNum,
|
|
|
|
renderBump_t *rb ) {
|
|
|
|
int i, j, k;
|
|
|
|
float bounds[2][2];
|
|
|
|
float ibounds[2][2];
|
|
|
|
float verts[3][2];
|
|
|
|
float testVert[2];
|
|
|
|
float bary[3];
|
|
|
|
byte *localDest, *globalDest, *colorDest;
|
|
|
|
float edge[3][3];
|
|
|
|
idVec3 sampledNormal;
|
2011-12-16 13:36:30 +00:00
|
|
|
byte sampledColor[4] = { };
|
2011-11-22 21:28:15 +00:00
|
|
|
idVec3 point, normal, traceNormal, tangents[2];
|
|
|
|
float baseArea, totalArea;
|
|
|
|
int r, g, b;
|
|
|
|
idVec3 localNormal;
|
|
|
|
|
|
|
|
// this is a brain-dead rasterizer, but compared to the ray trace,
|
|
|
|
// nothing we do here is going to matter performance-wise
|
|
|
|
|
|
|
|
// adjust for resolution and texel centers
|
|
|
|
verts[0][0] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+0] ].st[0] * rb->width - 0.5;
|
|
|
|
verts[1][0] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+1] ].st[0] * rb->width - 0.5;
|
|
|
|
verts[2][0] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+2] ].st[0] * rb->width - 0.5;
|
|
|
|
verts[0][1] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+0] ].st[1] * rb->height - 0.5;
|
|
|
|
verts[1][1] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+1] ].st[1] * rb->height - 0.5;
|
|
|
|
verts[2][1] = lowMesh->verts[ lowMesh->indexes[lowFaceNum*3+2] ].st[1] * rb->height - 0.5;
|
|
|
|
|
|
|
|
// find the texcoord bounding box
|
|
|
|
bounds[0][0] = 99999;
|
|
|
|
bounds[0][1] = 99999;
|
|
|
|
bounds[1][0] = -99999;
|
|
|
|
bounds[1][1] = -99999;
|
|
|
|
for ( i = 0 ; i < 2 ; i++ ) {
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
if ( verts[j][i] < bounds[0][i] ) {
|
|
|
|
bounds[0][i] = verts[j][i];
|
|
|
|
}
|
|
|
|
if ( verts[j][i] > bounds[1][i] ) {
|
|
|
|
bounds[1][i] = verts[j][i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// we intentionally rasterize somewhat outside the triangles, so
|
|
|
|
// the bilerp support texels (which may be anti-aliased down)
|
|
|
|
// are not just duplications of what is on the interior
|
|
|
|
const float edgeOverlap = 4.0;
|
|
|
|
|
|
|
|
ibounds[0][0] = floor( bounds[0][0] - edgeOverlap );
|
|
|
|
ibounds[1][0] = ceil( bounds[1][0] + edgeOverlap );
|
|
|
|
ibounds[0][1] = floor( bounds[0][1] - edgeOverlap );
|
|
|
|
ibounds[1][1] = ceil( bounds[1][1] + edgeOverlap );
|
|
|
|
|
|
|
|
// calculate edge vectors
|
|
|
|
for ( i = 0 ; i < 3 ; i++ ) {
|
|
|
|
float *v1, *v2;
|
2011-12-06 18:20:15 +00:00
|
|
|
|
2011-11-22 21:28:15 +00:00
|
|
|
v1 = verts[i];
|
|
|
|
v2 = verts[(i+1)%3];
|
|
|
|
|
|
|
|
edge[i][0] = v2[1] - v1[1];
|
|
|
|
edge[i][1] = v1[0] - v2[0];
|
|
|
|
float len = sqrt( edge[i][0] * edge[i][0] + edge[i][1] * edge[i][1] );
|
|
|
|
edge[i][0] /= len;
|
|
|
|
edge[i][1] /= len;
|
|
|
|
edge[i][2] = -( v1[0] * edge[i][0] + v1[1] * edge[i][1] );
|
|
|
|
}
|
|
|
|
|
|
|
|
// itterate over the bounding box, testing against edge vectors
|
|
|
|
for ( i = ibounds[0][1] ; i < ibounds[1][1] ; i++ ) {
|
|
|
|
for ( j = ibounds[0][0] ; j < ibounds[1][0] ; j++ ) {
|
|
|
|
float dists[3];
|
|
|
|
|
|
|
|
k = ( ( i & (rb->height-1) ) * rb->width + ( j & (rb->width-1) ) ) * 4;
|
|
|
|
colorDest = &rb->colorPic[k];
|
|
|
|
localDest = &rb->localPic[k];
|
|
|
|
globalDest = &rb->globalPic[k];
|
|
|
|
|
|
|
|
#define SKIP_MIRRORS
|
|
|
|
|
|
|
|
float *edgeDistance = &rb->edgeDistances[k/4];
|
|
|
|
#ifdef SKIP_MIRRORS
|
|
|
|
// if this texel has already been filled by a true interior pixel, don't overwrite it
|
|
|
|
if ( *edgeDistance == 0 ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// check against the three edges to see if the pixel is inside the triangle
|
|
|
|
for ( k = 0 ; k < 3 ; k++ ) {
|
|
|
|
float v;
|
|
|
|
|
|
|
|
v = i * edge[k][1] + j * edge[k][0] + edge[k][2];
|
|
|
|
dists[k] = v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// the edge polarities might be either way
|
|
|
|
if ( ! ( ( dists[0] >= -edgeOverlap && dists[1] >= -edgeOverlap && dists[2] >= -edgeOverlap )
|
|
|
|
|| ( dists[0] <= edgeOverlap && dists[1] <= edgeOverlap && dists[2] <= edgeOverlap ) ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool edgeTexel;
|
|
|
|
|
|
|
|
if ( ( dists[0] >= 0 && dists[1] >= 0 && dists[2] >= 0 )
|
|
|
|
|| ( dists[0] <= 0 && dists[1] <= 0 && dists[2] <= 0 ) ) {
|
|
|
|
edgeTexel = false;
|
|
|
|
} else {
|
|
|
|
edgeTexel = true;
|
|
|
|
#ifdef SKIP_MIRRORS
|
|
|
|
// if this texel has already been filled by another edge pixel, don't overwrite it
|
|
|
|
if ( *edgeDistance == 1 ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate the barycentric coordinates in the triangle for this sample
|
|
|
|
testVert[0] = j;
|
|
|
|
testVert[1] = i;
|
|
|
|
|
|
|
|
baseArea = TriTextureArea( verts[0], verts[1], verts[2] );
|
|
|
|
bary[0] = TriTextureArea( testVert, verts[1], verts[2] ) / baseArea;
|
|
|
|
bary[1] = TriTextureArea( verts[0], testVert, verts[2] ) / baseArea;
|
|
|
|
bary[2] = TriTextureArea( verts[0], verts[1], testVert ) / baseArea;
|
|
|
|
|
|
|
|
totalArea = bary[0] + bary[1] + bary[2];
|
|
|
|
if ( totalArea < 0.99 || totalArea > 1.01 ) {
|
|
|
|
continue; // should never happen
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate the interpolated xyz, normal, and tangents of this sample
|
|
|
|
point = vec3_origin;
|
|
|
|
traceNormal = vec3_origin;
|
|
|
|
normal = vec3_origin;
|
|
|
|
tangents[0] = vec3_origin;
|
|
|
|
tangents[1] = vec3_origin;
|
|
|
|
for ( k = 0 ; k < 3 ; k++ ) {
|
|
|
|
int index;
|
|
|
|
|
|
|
|
index = lowMesh->indexes[lowFaceNum*3+k];
|
|
|
|
point += bary[k] * lowMesh->verts[ index ].xyz;
|
|
|
|
|
|
|
|
// traceNormal will differ from normal if the surface uses unsmoothedTangents
|
|
|
|
traceNormal += bary[k] * lowMeshNormals[ index ];
|
|
|
|
|
|
|
|
normal += bary[k] * lowMesh->verts[ index ].normal;
|
|
|
|
tangents[0] += bary[k] * lowMesh->verts[ index ].tangents[0];
|
|
|
|
tangents[1] += bary[k] * lowMesh->verts[ index ].tangents[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// this doesn't seem to make much difference
|
|
|
|
// an argument can be made that these should not be normalized, because the interpolation
|
|
|
|
// of the light position at rasterization time will be linear, not spherical
|
|
|
|
normal.Normalize();
|
|
|
|
tangents[0].Normalize();
|
|
|
|
tangents[1].Normalize();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// find the best triangle in the high poly model for this
|
|
|
|
// sampledNormal will normalized
|
|
|
|
if ( !SampleHighMesh( rb, point, traceNormal, sampledNormal, sampledColor ) ) {
|
|
|
|
#if 0
|
|
|
|
// put bright red where all traces missed for debugging.
|
|
|
|
// for production use, it is better to leave it blank so
|
|
|
|
// the outlining fills it in
|
|
|
|
globalDest[0] = 255;
|
|
|
|
globalDest[1] = 0;
|
|
|
|
globalDest[2] = 0;
|
|
|
|
globalDest[3] = 255;
|
|
|
|
|
|
|
|
localDest[0] = 255;
|
|
|
|
localDest[1] = 0;
|
|
|
|
localDest[2] = 0;
|
|
|
|
localDest[3] = 255;
|
|
|
|
#endif
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// mark whether this is an interior or edge texel
|
|
|
|
*edgeDistance = ( edgeTexel ? 1.0 : 0 );
|
|
|
|
|
|
|
|
// fill the object space normal map spot
|
|
|
|
r = 128 + 127 * sampledNormal[0];
|
|
|
|
g = 128 + 127 * sampledNormal[1];
|
|
|
|
b = 128 + 127 * sampledNormal[2];
|
|
|
|
|
|
|
|
globalDest[0] = r;
|
|
|
|
globalDest[1] = g;
|
|
|
|
globalDest[2] = b;
|
|
|
|
globalDest[3] = 255;
|
|
|
|
|
|
|
|
// transform to local tangent space
|
|
|
|
idMat3 mat;
|
|
|
|
mat[0] = tangents[0];
|
|
|
|
mat[1] = tangents[1];
|
|
|
|
mat[2] = normal;
|
|
|
|
mat.InverseSelf();
|
|
|
|
localNormal = mat * sampledNormal;
|
|
|
|
|
|
|
|
localNormal.Normalize();
|
|
|
|
|
|
|
|
|
|
|
|
r = 128 + 127 * localNormal[0];
|
|
|
|
g = 128 + 127 * localNormal[1];
|
|
|
|
b = 128 + 127 * localNormal[2];
|
|
|
|
|
|
|
|
localDest[0] = r;
|
|
|
|
localDest[1] = g;
|
|
|
|
localDest[2] = b;
|
|
|
|
localDest[3] = 255;
|
|
|
|
|
|
|
|
colorDest[0] = sampledColor[0];
|
|
|
|
colorDest[1] = sampledColor[1];
|
|
|
|
colorDest[2] = sampledColor[2];
|
|
|
|
colorDest[3] = sampledColor[3];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
================
|
|
|
|
CombineModelSurfaces
|
|
|
|
|
|
|
|
Frees the model and returns a new model with all triangles combined
|
|
|
|
into one surface
|
|
|
|
================
|
|
|
|
*/
|
|
|
|
static idRenderModel *CombineModelSurfaces( idRenderModel *model ) {
|
|
|
|
int totalVerts;
|
|
|
|
int totalIndexes;
|
|
|
|
int numIndexes;
|
|
|
|
int numVerts;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
totalVerts = 0;
|
|
|
|
totalIndexes = 0;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
|
|
|
|
const modelSurface_t *surf = model->Surface(i);
|
|
|
|
|
|
|
|
totalVerts += surf->geometry->numVerts;
|
|
|
|
totalIndexes += surf->geometry->numIndexes;
|
|
|
|
}
|
|
|
|
|
|
|
|
srfTriangles_t *newTri = R_AllocStaticTriSurf();
|
|
|
|
R_AllocStaticTriSurfVerts( newTri, totalVerts );
|
|
|
|
R_AllocStaticTriSurfIndexes( newTri, totalIndexes );
|
|
|
|
|
|
|
|
newTri->numVerts = totalVerts;
|
|
|
|
newTri->numIndexes = totalIndexes;
|
|
|
|
|
|
|
|
newTri->bounds.Clear();
|
|
|
|
|
|
|
|
idDrawVert *verts = newTri->verts;
|
|
|
|
glIndex_t *indexes = newTri->indexes;
|
|
|
|
numIndexes = 0;
|
|
|
|
numVerts = 0;
|
|
|
|
for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
|
|
|
|
const modelSurface_t *surf = model->Surface(i);
|
|
|
|
const srfTriangles_t *tri = surf->geometry;
|
|
|
|
|
|
|
|
memcpy( verts + numVerts, tri->verts, tri->numVerts * sizeof( tri->verts[0] ) );
|
|
|
|
for ( j = 0 ; j < tri->numIndexes ; j++ ) {
|
|
|
|
indexes[numIndexes+j] = numVerts + tri->indexes[j];
|
|
|
|
}
|
|
|
|
newTri->bounds.AddBounds( tri->bounds );
|
|
|
|
numIndexes += tri->numIndexes;
|
|
|
|
numVerts += tri->numVerts;
|
|
|
|
}
|
|
|
|
|
|
|
|
modelSurface_t surf;
|
|
|
|
|
|
|
|
surf.id = 0;
|
|
|
|
surf.geometry = newTri;
|
|
|
|
surf.shader = tr.defaultMaterial;
|
|
|
|
|
|
|
|
idRenderModel *newModel = renderModelManager->AllocModel();
|
|
|
|
newModel->AddSurface( surf );
|
|
|
|
|
|
|
|
renderModelManager->FreeModel( model );
|
|
|
|
|
|
|
|
return newModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
==============
|
|
|
|
RenderBumpTriangles
|
|
|
|
|
|
|
|
==============
|
|
|
|
*/
|
|
|
|
static void RenderBumpTriangles( srfTriangles_t *lowMesh, renderBump_t *rb ) {
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
RB_SetGL2D();
|
|
|
|
|
|
|
|
qglDisable( GL_CULL_FACE );
|
|
|
|
|
|
|
|
qglColor3f( 1, 1, 1 );
|
|
|
|
|
|
|
|
qglMatrixMode( GL_PROJECTION );
|
|
|
|
qglLoadIdentity();
|
|
|
|
qglOrtho( 0, 1, 1, 0, -1, 1 );
|
|
|
|
qglDisable( GL_BLEND );
|
|
|
|
qglMatrixMode( GL_MODELVIEW );
|
|
|
|
qglLoadIdentity();
|
|
|
|
|
|
|
|
qglDisable( GL_DEPTH_TEST );
|
|
|
|
|
|
|
|
qglClearColor(1,0,0,1);
|
|
|
|
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
|
|
|
|
|
|
|
|
qglColor3f( 1, 1, 1 );
|
|
|
|
|
|
|
|
// create smoothed normals for the surface, which might be
|
|
|
|
// different than the normals at the vertexes if the
|
|
|
|
// surface uses unsmoothedNormals, which only takes the
|
|
|
|
// normal from a single triangle. We need properly smoothed
|
|
|
|
// normals to make sure that the traces always go off normal
|
|
|
|
// to the true surface.
|
|
|
|
idVec3 *lowMeshNormals = (idVec3 *)Mem_ClearedAlloc( lowMesh->numVerts * sizeof( *lowMeshNormals ) );
|
|
|
|
R_DeriveFacePlanes( lowMesh );
|
|
|
|
R_CreateSilIndexes( lowMesh ); // recreate, merging the mirrored verts back together
|
|
|
|
const idPlane *planes = lowMesh->facePlanes;
|
|
|
|
for ( i = 0 ; i < lowMesh->numIndexes ; i += 3, planes++ ) {
|
|
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
|
|
int index;
|
|
|
|
|
|
|
|
index = lowMesh->silIndexes[i+j];
|
|
|
|
lowMeshNormals[index] += (*planes).Normal();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// normalize and replicate from silIndexes to all indexes
|
|
|
|
for ( i = 0 ; i < lowMesh->numIndexes ; i++ ) {
|
|
|
|
lowMeshNormals[lowMesh->indexes[i]] = lowMeshNormals[lowMesh->silIndexes[i]];
|
|
|
|
lowMeshNormals[lowMesh->indexes[i]].Normalize();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// rasterize each low poly face
|
|
|
|
for ( j = 0 ; j < lowMesh->numIndexes ; j+=3 ) {
|
|
|
|
// pump the event loop so the window can be dragged around
|
|
|
|
Sys_GenerateEvents();
|
|
|
|
|
|
|
|
RasterizeTriangle( lowMesh, lowMeshNormals, j/3, rb );
|
|
|
|
|
|
|
|
qglClearColor(1,0,0,1);
|
|
|
|
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
|
|
|
|
qglRasterPos2f( 0, 1 );
|
|
|
|
qglPixelZoom( glConfig.vidWidth / (float)rb->width, glConfig.vidHeight / (float)rb->height );
|
|
|
|
qglDrawPixels( rb->width, rb->height, GL_RGBA, GL_UNSIGNED_BYTE, rb->localPic );
|
|
|
|
qglPixelZoom( 1, 1 );
|
|
|
|
qglFlush();
|
|
|
|
GLimp_SwapBuffers();
|
|
|
|
}
|
|
|
|
|
|
|
|
Mem_Free( lowMeshNormals );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
==============
|
|
|
|
WriteRenderBump
|
|
|
|
|
|
|
|
==============
|
|
|
|
*/
|
|
|
|
static void WriteRenderBump( renderBump_t *rb, int outLinePixels ) {
|
|
|
|
int width, height;
|
|
|
|
int i;
|
|
|
|
idStr filename;
|
|
|
|
|
|
|
|
renderModelManager->FreeModel( rb->highModel );
|
|
|
|
|
|
|
|
FreeTriHash( rb->hash );
|
|
|
|
|
|
|
|
width = rb->width;
|
|
|
|
height = rb->height;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// save the non-outlined version
|
|
|
|
filename = source;
|
|
|
|
filename.setFileExtension();
|
|
|
|
filename.append( "_nooutline.tga" );
|
|
|
|
common->Printf( "writing %s\n", filename.c_str() );
|
|
|
|
WriteTGA( filename, globalPic, width, height );
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// outline the image several times to help bilinear filtering across disconnected
|
|
|
|
// edges, and mip-mapping
|
|
|
|
for ( i = 0 ; i < outLinePixels ; i++ ) {
|
|
|
|
OutlineNormalMap( rb->localPic, width, height, 128, 128, 128 );
|
|
|
|
OutlineNormalMap( rb->globalPic, width, height, 128, 128, 128 );
|
|
|
|
OutlineColorMap( rb->colorPic, width, height, 128, 128, 128 );
|
|
|
|
}
|
|
|
|
|
|
|
|
// filter down if we are anti-aliasing
|
|
|
|
for ( i = 0 ; i < rb->antiAlias ; i++ ) {
|
|
|
|
byte *old;
|
|
|
|
|
|
|
|
old = rb->localPic;
|
|
|
|
rb->localPic = R_MipMap( rb->localPic, width, height, false );
|
|
|
|
Mem_Free( old );
|
|
|
|
|
|
|
|
old = rb->globalPic;
|
|
|
|
rb->globalPic = R_MipMap( rb->globalPic, width, height, false );
|
|
|
|
Mem_Free( old );
|
|
|
|
|
|
|
|
old = rb->colorPic;
|
|
|
|
rb->colorPic = R_MipMap( rb->colorPic, width, height, false );
|
|
|
|
Mem_Free( old );
|
|
|
|
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// write out the local map
|
|
|
|
filename = rb->outputName;
|
|
|
|
filename.SetFileExtension( ".tga" );
|
|
|
|
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
|
|
|
|
R_WriteTGA( filename, rb->localPic, width, height );
|
|
|
|
|
|
|
|
if ( rb->saveGlobalMap ) {
|
|
|
|
filename = rb->outputName;
|
|
|
|
filename.StripFileExtension();
|
|
|
|
filename.Append( "_global.tga" );
|
|
|
|
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
|
|
|
|
R_WriteTGA( filename, rb->globalPic, width, height );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( rb->saveColorMap ) {
|
|
|
|
filename = rb->outputName;
|
|
|
|
filename.StripFileExtension();
|
|
|
|
filename.Append( "_color.tga" );
|
|
|
|
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
|
|
|
|
R_WriteTGA( filename, rb->colorPic, width, height );
|
|
|
|
}
|
|
|
|
|
|
|
|
Mem_Free( rb->localPic );
|
|
|
|
Mem_Free( rb->globalPic );
|
|
|
|
Mem_Free( rb->colorPic );
|
|
|
|
Mem_Free( rb->edgeDistances );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
===============
|
|
|
|
InitRenderBump
|
|
|
|
===============
|
|
|
|
*/
|
|
|
|
static void InitRenderBump( renderBump_t *rb ) {
|
|
|
|
srfTriangles_t *mesh;
|
|
|
|
idBounds bounds;
|
|
|
|
int i, c;
|
|
|
|
|
|
|
|
// load the ase file
|
|
|
|
common->Printf( "loading %s...\n", rb->highName );
|
|
|
|
|
|
|
|
rb->highModel = renderModelManager->AllocModel();
|
|
|
|
rb->highModel->PartialInitFromFile( rb->highName );
|
|
|
|
if ( !rb->highModel ) {
|
|
|
|
common->Error( "failed to load %s", rb->highName );
|
|
|
|
}
|
|
|
|
|
|
|
|
// combine the high poly model into a single polyset
|
|
|
|
if ( rb->highModel->NumSurfaces() != 1 ) {
|
|
|
|
rb->highModel = CombineModelSurfaces( rb->highModel );
|
|
|
|
}
|
|
|
|
|
|
|
|
const modelSurface_t *surf = rb->highModel->Surface( 0 );
|
|
|
|
mesh = surf->geometry;
|
|
|
|
|
|
|
|
rb->mesh = mesh;
|
|
|
|
|
|
|
|
R_DeriveFacePlanes( mesh );
|
|
|
|
|
|
|
|
// create a face hash table to accelerate the tracing
|
|
|
|
rb->hash = CreateTriHash( mesh );
|
|
|
|
|
|
|
|
// bound the entire file
|
|
|
|
R_BoundTriSurf( mesh );
|
|
|
|
bounds = mesh->bounds;
|
|
|
|
|
|
|
|
// the traceDist will be the traceFrac times the larges bounds axis
|
|
|
|
rb->traceDist = 0;
|
|
|
|
for ( i = 0 ; i < 3 ; i++ ) {
|
|
|
|
float d;
|
|
|
|
|
|
|
|
d = rb->traceFrac * ( bounds[1][i] - bounds[0][i] );
|
|
|
|
if ( d > rb->traceDist ) {
|
|
|
|
rb->traceDist = d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
common->Printf( "trace fraction %4.2f = %6.2f model units\n", rb->traceFrac, rb->traceDist );
|
|
|
|
|
|
|
|
c = rb->width * rb->height * 4;
|
|
|
|
|
|
|
|
// local normal map
|
|
|
|
rb->localPic = (byte *)Mem_Alloc( c );
|
|
|
|
|
|
|
|
// global (object space, not surface space) normal map
|
|
|
|
rb->globalPic = (byte *)Mem_Alloc( c );
|
|
|
|
|
|
|
|
// color pic for artist reference
|
|
|
|
rb->colorPic = (byte *)Mem_Alloc( c );
|
|
|
|
|
|
|
|
// edgeDistance for marking outside-the-triangle traces
|
|
|
|
rb->edgeDistances = (float *)Mem_Alloc( c );
|
|
|
|
|
|
|
|
for ( i = 0 ; i < c ; i+=4 ) {
|
|
|
|
rb->localPic[i+0] = 128;
|
|
|
|
rb->localPic[i+1] = 128;
|
|
|
|
rb->localPic[i+2] = 128;
|
|
|
|
rb->localPic[i+3] = 0; // the artists use this for masking traced pixels sometimes
|
|
|
|
|
|
|
|
rb->globalPic[i+0] = 128;
|
|
|
|
rb->globalPic[i+1] = 128;
|
|
|
|
rb->globalPic[i+2] = 128;
|
|
|
|
rb->globalPic[i+3] = 0;
|
|
|
|
|
|
|
|
rb->colorPic[i+0] = 128;
|
|
|
|
rb->colorPic[i+1] = 128;
|
|
|
|
rb->colorPic[i+2] = 128;
|
|
|
|
rb->colorPic[i+3] = 0;
|
|
|
|
|
|
|
|
rb->edgeDistances[i/4] = -1; // not traced yet
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
==============
|
|
|
|
RenderBump_f
|
|
|
|
|
|
|
|
==============
|
|
|
|
*/
|
|
|
|
void RenderBump_f( const idCmdArgs &args ) {
|
|
|
|
idRenderModel *lowPoly;
|
|
|
|
idStr source;
|
|
|
|
int i, j;
|
|
|
|
const char *cmdLine;
|
|
|
|
int numRenderBumps;
|
2011-12-02 22:39:30 +00:00
|
|
|
renderBump_t *renderBumps, *rb = NULL;
|
2011-11-22 21:28:15 +00:00
|
|
|
renderBump_t opt;
|
|
|
|
int startTime, endTime;
|
|
|
|
|
|
|
|
// update the screen as we print
|
|
|
|
common->SetRefreshOnPrint( true );
|
|
|
|
|
|
|
|
// there should be a single parameter, the filename for a game loadable low-poly model
|
|
|
|
if ( args.Argc() != 2 ) {
|
|
|
|
common->Error( "Usage: renderbump <lowPolyModel>" );
|
|
|
|
}
|
|
|
|
|
|
|
|
common->Printf( "----- Renderbump %s -----\n", args.Argv( 1 ) );
|
|
|
|
|
|
|
|
startTime = Sys_Milliseconds();
|
|
|
|
|
|
|
|
// get the lowPoly model
|
|
|
|
source = args.Argv( 1 );
|
|
|
|
lowPoly = renderModelManager->CheckModel( source );
|
|
|
|
if ( !lowPoly ) {
|
|
|
|
common->Error( "Can't load model %s", source.c_str() );
|
|
|
|
}
|
|
|
|
|
|
|
|
renderBumps = (renderBump_t *)R_StaticAlloc( lowPoly->NumSurfaces() * sizeof( *renderBumps ) );
|
|
|
|
numRenderBumps = 0;
|
|
|
|
for ( i = 0 ; i < lowPoly->NumSurfaces() ; i++ ) {
|
|
|
|
const modelSurface_t *ms = lowPoly->Surface( i );
|
|
|
|
|
|
|
|
// default options
|
|
|
|
memset( &opt, 0, sizeof( opt ) );
|
|
|
|
opt.width = 512;
|
|
|
|
opt.height = 512;
|
|
|
|
opt.antiAlias = 1;
|
|
|
|
opt.outline = 8;
|
|
|
|
opt.traceFrac = 0.05f;
|
|
|
|
|
|
|
|
// parse the renderbump parameters for this surface
|
|
|
|
cmdLine = ms->shader->GetRenderBump();
|
|
|
|
|
2011-12-06 18:20:15 +00:00
|
|
|
common->Printf( "surface %i, shader %s\nrenderBump = %s ", i,
|
2011-11-22 21:28:15 +00:00
|
|
|
ms->shader->GetName(), cmdLine );
|
|
|
|
|
|
|
|
if ( !ms->geometry ) {
|
|
|
|
common->Printf( "(no geometry)\n" );
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
idCmdArgs localArgs;
|
|
|
|
localArgs.TokenizeString( cmdLine, false );
|
|
|
|
|
|
|
|
if ( localArgs.Argc() < 2 ) {
|
|
|
|
common->Printf( "(no action)\n" );
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
common->Printf( "(rendering)\n" );
|
|
|
|
|
|
|
|
for ( j = 0 ; j < localArgs.Argc() - 2; j++ ) {
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
s = localArgs.Argv( j );
|
|
|
|
if ( s[0] == '-' ) {
|
|
|
|
j++;
|
|
|
|
s = localArgs.Argv( j );
|
|
|
|
if ( s[0] == '\0' ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !idStr::Icmp( s, "size" ) ) {
|
|
|
|
if ( j + 2 >= localArgs.Argc() ) {
|
|
|
|
j = localArgs.Argc();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
opt.width = atoi( localArgs.Argv( j + 1 ) );
|
|
|
|
opt.height = atoi( localArgs.Argv( j + 2 ) );
|
|
|
|
j += 2;
|
|
|
|
} else if ( !idStr::Icmp( s, "trace" ) ) {
|
|
|
|
opt.traceFrac = atof( localArgs.Argv( j + 1 ) );
|
|
|
|
j += 1;
|
|
|
|
} else if ( !idStr::Icmp( s, "globalMap" ) ) {
|
|
|
|
opt.saveGlobalMap = true;
|
|
|
|
} else if ( !idStr::Icmp( s, "colorMap" ) ) {
|
|
|
|
opt.saveColorMap = true;
|
|
|
|
} else if ( !idStr::Icmp( s, "outline" ) ) {
|
|
|
|
opt.outline = atoi( localArgs.Argv( j + 1 ) );
|
|
|
|
j += 1;
|
|
|
|
} else if ( !idStr::Icmp( s, "aa" ) ) {
|
|
|
|
opt.antiAlias = atoi( localArgs.Argv( j + 1 ) );
|
|
|
|
j += 1;
|
|
|
|
} else {
|
|
|
|
common->Printf( "WARNING: Unknown option \"%s\"\n", s );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( j != ( localArgs.Argc() - 2 ) ) {
|
|
|
|
common->Error( "usage: renderBump [-size width height] [-aa <1-2>] [globalMap] [colorMap] [-trace <0.01 - 1.0>] normalMapImageFile highPolyAseFile" );
|
|
|
|
}
|
|
|
|
idStr::Copynz( opt.outputName, localArgs.Argv( j ), sizeof( opt.outputName ) );
|
|
|
|
idStr::Copynz( opt.highName, localArgs.Argv( j + 1 ), sizeof( opt.highName ) );
|
|
|
|
|
|
|
|
// adjust size for anti-aliasing
|
|
|
|
opt.width <<= opt.antiAlias;
|
|
|
|
opt.height <<= opt.antiAlias;
|
|
|
|
|
|
|
|
// see if we already have a renderbump going for another surface that this should use
|
|
|
|
for ( j = 0 ; j < numRenderBumps ; j++ ) {
|
|
|
|
rb = &renderBumps[j];
|
|
|
|
|
|
|
|
if ( idStr::Icmp( rb->outputName, opt.outputName ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// all the other parameters must match, or it is an error
|
2011-12-06 18:20:15 +00:00
|
|
|
if ( idStr::Icmp( rb->highName, opt.highName) || rb->width != opt.width ||
|
|
|
|
rb->height != opt.height || rb->antiAlias != opt.antiAlias ||
|
2011-11-22 21:28:15 +00:00
|
|
|
rb->traceFrac != opt.traceFrac ) {
|
|
|
|
common->Error( "mismatched renderbump parameters on image %s", rb->outputName );
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// saveGlobalMap will be a sticky option
|
|
|
|
rb->saveGlobalMap = rb->saveGlobalMap | opt.saveGlobalMap;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// create a new renderbump if needed
|
|
|
|
if ( j == numRenderBumps ) {
|
|
|
|
numRenderBumps++;
|
|
|
|
rb = &renderBumps[j];
|
|
|
|
*rb = opt;
|
|
|
|
|
|
|
|
InitRenderBump( rb );
|
|
|
|
}
|
|
|
|
|
|
|
|
// render the triangles for this surface
|
|
|
|
RenderBumpTriangles( ms->geometry, rb );
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// anti-alias and write out all renderbumps that we have completed
|
|
|
|
//
|
|
|
|
for ( i = 0 ; i < numRenderBumps ; i++ ) {
|
|
|
|
WriteRenderBump( &renderBumps[i], opt.outline << opt.antiAlias );
|
|
|
|
}
|
|
|
|
|
|
|
|
R_StaticFree( renderBumps );
|
|
|
|
|
|
|
|
endTime = Sys_Milliseconds();
|
|
|
|
common->Printf( "%5.2f seconds for renderBump\n", ( endTime - startTime ) / 1000.0 );
|
|
|
|
common->Printf( "---------- RenderBump Completed ----------\n" );
|
|
|
|
|
|
|
|
// stop updating the screen as we print
|
|
|
|
common->SetRefreshOnPrint( false );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
==================================================================================
|
|
|
|
|
|
|
|
FLAT
|
|
|
|
|
|
|
|
The flat case is trivial, and accomplished with hardware rendering
|
|
|
|
|
|
|
|
==================================================================================
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
==============
|
|
|
|
RenderBumpFlat_f
|
|
|
|
|
|
|
|
==============
|
|
|
|
*/
|
|
|
|
void RenderBumpFlat_f( const idCmdArgs &args ) {
|
|
|
|
int width, height;
|
|
|
|
idStr source;
|
|
|
|
int i;
|
|
|
|
idBounds bounds;
|
|
|
|
srfTriangles_t *mesh;
|
|
|
|
|
|
|
|
// update the screen as we print
|
|
|
|
common->SetRefreshOnPrint( true );
|
|
|
|
|
|
|
|
width = height = 256;
|
|
|
|
|
|
|
|
// check options
|
|
|
|
for ( i = 1 ; i < args.Argc() - 1; i++ ) {
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
s = args.Argv( i );
|
|
|
|
if ( s[0] == '-' ) {
|
|
|
|
i++;
|
|
|
|
s = args.Argv( i );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !idStr::Icmp( s, "size" ) ) {
|
|
|
|
if ( i + 2 >= args.Argc() ) {
|
|
|
|
i = args.Argc();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
width = atoi( args.Argv( i + 1 ) );
|
|
|
|
height = atoi( args.Argv( i + 2 ) );
|
|
|
|
i += 2;
|
|
|
|
} else {
|
|
|
|
common->Printf( "WARNING: Unknown option \"%s\"\n", s );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( i != ( args.Argc() - 1 ) ) {
|
|
|
|
common->Error( "usage: renderBumpFlat [-size width height] asefile" );
|
2011-12-02 22:39:30 +00:00
|
|
|
return;
|
2011-11-22 21:28:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
common->Printf( "Final image size: %i, %i\n", width, height );
|
|
|
|
|
|
|
|
// load the source in "fastload" mode, because we don't
|
|
|
|
// need tangent and shadow information
|
|
|
|
source = args.Argv( i );
|
|
|
|
|
|
|
|
idRenderModel *highPolyModel = renderModelManager->AllocModel();
|
|
|
|
|
|
|
|
highPolyModel->PartialInitFromFile( source );
|
|
|
|
|
|
|
|
if ( highPolyModel->IsDefaultModel() ) {
|
|
|
|
common->Error( "failed to load %s", source.c_str() );
|
|
|
|
}
|
|
|
|
|
|
|
|
// combine the high poly model into a single polyset
|
|
|
|
if ( highPolyModel->NumSurfaces() != 1 ) {
|
|
|
|
highPolyModel = CombineModelSurfaces( highPolyModel );
|
|
|
|
}
|
|
|
|
|
|
|
|
// create normals if not present in file
|
|
|
|
const modelSurface_t *surf = highPolyModel->Surface( 0 );
|
|
|
|
mesh = surf->geometry;
|
|
|
|
|
|
|
|
// bound the entire file
|
|
|
|
R_BoundTriSurf( mesh );
|
|
|
|
bounds = mesh->bounds;
|
|
|
|
|
|
|
|
SaveWindow();
|
|
|
|
ResizeWindow( width, height );
|
|
|
|
|
|
|
|
// for small images, the viewport may be less than the minimum window
|
|
|
|
qglViewport( 0, 0, width, height );
|
|
|
|
|
|
|
|
qglEnable( GL_CULL_FACE );
|
|
|
|
qglCullFace( GL_FRONT );
|
2011-12-06 18:20:15 +00:00
|
|
|
qglDisable( GL_STENCIL_TEST );
|
|
|
|
qglDisable( GL_SCISSOR_TEST );
|
|
|
|
qglDisable( GL_ALPHA_TEST );
|
|
|
|
qglDisable( GL_BLEND );
|
2011-11-22 21:28:15 +00:00
|
|
|
qglEnable( GL_DEPTH_TEST );
|
|
|
|
qglDisable( GL_TEXTURE_2D );
|
|
|
|
qglDepthMask( GL_TRUE );
|
|
|
|
qglDepthFunc( GL_LEQUAL );
|
|
|
|
|
|
|
|
qglColor3f( 1, 1, 1 );
|
|
|
|
|
|
|
|
qglMatrixMode( GL_PROJECTION );
|
|
|
|
qglLoadIdentity();
|
2011-12-06 18:20:15 +00:00
|
|
|
qglOrtho( bounds[0][0], bounds[1][0], bounds[0][2],
|
2011-11-22 21:28:15 +00:00
|
|
|
bounds[1][2], -( bounds[0][1] - 1 ), -( bounds[1][1] + 1 ) );
|
|
|
|
|
|
|
|
qglMatrixMode( GL_MODELVIEW );
|
|
|
|
qglLoadIdentity();
|
|
|
|
|
|
|
|
// flat maps are automatically anti-aliased
|
|
|
|
|
|
|
|
idStr filename;
|
|
|
|
int j, k, c;
|
|
|
|
byte *buffer;
|
|
|
|
int *sumBuffer, *colorSumBuffer;
|
|
|
|
bool flat;
|
|
|
|
int sample;
|
|
|
|
|
|
|
|
sumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
|
|
|
|
memset( sumBuffer, 0, width * height * 4 * 4 );
|
|
|
|
buffer = (byte *)Mem_Alloc( width * height * 4 );
|
|
|
|
|
|
|
|
colorSumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
|
|
|
|
memset( sumBuffer, 0, width * height * 4 * 4 );
|
|
|
|
|
|
|
|
flat = false;
|
|
|
|
//flat = true;
|
|
|
|
|
|
|
|
for ( sample = 0 ; sample < 16 ; sample++ ) {
|
|
|
|
float xOff, yOff;
|
|
|
|
|
|
|
|
xOff = ( ( sample & 3 ) / 4.0 ) * ( bounds[1][0] - bounds[0][0] ) / width;
|
|
|
|
yOff = ( ( sample / 4 ) / 4.0 ) * ( bounds[1][2] - bounds[0][2] ) / height;
|
|
|
|
|
|
|
|
for ( int colorPass = 0 ; colorPass < 2 ; colorPass++ ) {
|
|
|
|
qglClearColor(0.5,0.5,0.5,0);
|
|
|
|
qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
|
|
|
|
|
|
|
|
qglBegin( GL_TRIANGLES );
|
|
|
|
for ( i = 0 ; i < highPolyModel->NumSurfaces() ; i++ ) {
|
|
|
|
const modelSurface_t *surf = highPolyModel->Surface( i );
|
|
|
|
|
|
|
|
mesh = surf->geometry;
|
|
|
|
|
|
|
|
if ( colorPass ) {
|
|
|
|
// just render the surface color for artist visualization
|
|
|
|
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
|
|
|
|
for ( k = 0 ; k < 3 ; k++ ) {
|
|
|
|
int v;
|
|
|
|
float *a;
|
|
|
|
|
|
|
|
v = mesh->indexes[j+k];
|
|
|
|
qglColor3ubv( mesh->verts[v].color );
|
|
|
|
a = mesh->verts[v].xyz.ToFloatPtr();
|
|
|
|
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// render as normal map
|
|
|
|
// we can either flat shade from the plane,
|
|
|
|
// or smooth shade from the vertex normals
|
|
|
|
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
|
|
|
|
if ( flat ) {
|
|
|
|
idPlane plane;
|
|
|
|
idVec3 *a, *b, *c;
|
|
|
|
int v1, v2, v3;
|
|
|
|
|
|
|
|
v1 = mesh->indexes[j+0];
|
|
|
|
v2 = mesh->indexes[j+1];
|
|
|
|
v3 = mesh->indexes[j+2];
|
|
|
|
|
|
|
|
a = &mesh->verts[ v1 ].xyz;
|
|
|
|
b = &mesh->verts[ v2 ].xyz;
|
|
|
|
c = &mesh->verts[ v3 ].xyz;
|
|
|
|
|
|
|
|
plane.FromPoints( *a, *b, *c );
|
|
|
|
|
|
|
|
// NULLNORMAL is used by the artists to force an area to reflect no
|
|
|
|
// light at all
|
|
|
|
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
|
|
|
|
qglColor3f( 0.5, 0.5, 0.5 );
|
|
|
|
} else {
|
|
|
|
qglColor3f( 0.5 + 0.5*plane[0], 0.5 - 0.5*plane[2], 0.5 - 0.5*plane[1] );
|
|
|
|
}
|
|
|
|
|
|
|
|
qglVertex3f( (*a)[0] + xOff, (*a)[2] + yOff, (*a)[1] );
|
|
|
|
qglVertex3f( (*b)[0] + xOff, (*b)[2] + yOff, (*b)[1] );
|
|
|
|
qglVertex3f( (*c)[0] + xOff, (*c)[2] + yOff, (*c)[1] );
|
|
|
|
} else {
|
|
|
|
for ( k = 0 ; k < 3 ; k++ ) {
|
|
|
|
int v;
|
|
|
|
float *n;
|
|
|
|
float *a;
|
|
|
|
|
|
|
|
v = mesh->indexes[j+k];
|
|
|
|
n = mesh->verts[v].normal.ToFloatPtr();
|
|
|
|
|
|
|
|
// NULLNORMAL is used by the artists to force an area to reflect no
|
|
|
|
// light at all
|
|
|
|
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
|
|
|
|
qglColor3f( 0.5, 0.5, 0.5 );
|
|
|
|
} else {
|
|
|
|
// we are going to flip the normal Z direction
|
|
|
|
qglColor3f( 0.5 + 0.5*n[0], 0.5 - 0.5*n[2], 0.5 - 0.5*n[1] );
|
|
|
|
}
|
|
|
|
|
|
|
|
a = mesh->verts[v].xyz.ToFloatPtr();
|
|
|
|
qglVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qglEnd();
|
|
|
|
qglFlush();
|
|
|
|
GLimp_SwapBuffers();
|
2011-12-06 18:20:15 +00:00
|
|
|
qglReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer );
|
2011-11-22 21:28:15 +00:00
|
|
|
|
2011-12-02 22:39:30 +00:00
|
|
|
c = width * height;
|
|
|
|
|
2011-11-22 21:28:15 +00:00
|
|
|
if ( colorPass ) {
|
|
|
|
// add to the sum buffer
|
|
|
|
for ( i = 0 ; i < c ; i++ ) {
|
|
|
|
colorSumBuffer[i*4+0] += buffer[i*4+0];
|
|
|
|
colorSumBuffer[i*4+1] += buffer[i*4+1];
|
|
|
|
colorSumBuffer[i*4+2] += buffer[i*4+2];
|
|
|
|
colorSumBuffer[i*4+3] += buffer[i*4+3];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// normalize
|
|
|
|
for ( i = 0 ; i < c ; i++ ) {
|
|
|
|
idVec3 v;
|
|
|
|
|
|
|
|
v[0] = ( buffer[i*4+0] - 128 ) / 127.0;
|
|
|
|
v[1] = ( buffer[i*4+1] - 128 ) / 127.0;
|
|
|
|
v[2] = ( buffer[i*4+2] - 128 ) / 127.0;
|
|
|
|
|
|
|
|
v.Normalize();
|
|
|
|
|
|
|
|
buffer[i*4+0] = 128 + 127 * v[0];
|
|
|
|
buffer[i*4+1] = 128 + 127 * v[1];
|
|
|
|
buffer[i*4+2] = 128 + 127 * v[2];
|
|
|
|
}
|
|
|
|
|
|
|
|
// outline into non-drawn areas
|
|
|
|
for ( i = 0 ; i < 8 ; i++ ) {
|
|
|
|
OutlineNormalMap( buffer, width, height, 128, 128, 128 );
|
|
|
|
}
|
|
|
|
|
|
|
|
// add to the sum buffer
|
|
|
|
for ( i = 0 ; i < c ; i++ ) {
|
|
|
|
sumBuffer[i*4+0] += buffer[i*4+0];
|
|
|
|
sumBuffer[i*4+1] += buffer[i*4+1];
|
|
|
|
sumBuffer[i*4+2] += buffer[i*4+2];
|
|
|
|
sumBuffer[i*4+3] += buffer[i*4+3];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
c = width * height;
|
|
|
|
|
|
|
|
// save out the color map
|
|
|
|
for ( i = 0 ; i < c ; i++ ) {
|
|
|
|
buffer[i*4+0] = colorSumBuffer[i*4+0] / 16;
|
|
|
|
buffer[i*4+1] = colorSumBuffer[i*4+1] / 16;
|
|
|
|
buffer[i*4+2] = colorSumBuffer[i*4+2] / 16;
|
|
|
|
buffer[i*4+3] = colorSumBuffer[i*4+3] / 16;
|
|
|
|
}
|
|
|
|
filename = source;
|
|
|
|
filename.StripFileExtension();
|
|
|
|
filename.Append( "_color.tga" );
|
|
|
|
R_VerticalFlip( buffer, width, height );
|
|
|
|
R_WriteTGA( filename, buffer, width, height );
|
|
|
|
|
|
|
|
// save out the local map
|
|
|
|
// scale the sum buffer back down to the sample buffer
|
|
|
|
// we allow this to denormalize
|
|
|
|
for ( i = 0 ; i < c ; i++ ) {
|
|
|
|
buffer[i*4+0] = sumBuffer[i*4+0] / 16;
|
|
|
|
buffer[i*4+1] = sumBuffer[i*4+1] / 16;
|
|
|
|
buffer[i*4+2] = sumBuffer[i*4+2] / 16;
|
|
|
|
buffer[i*4+3] = sumBuffer[i*4+3] / 16;
|
|
|
|
}
|
|
|
|
|
|
|
|
filename = source;
|
|
|
|
filename.StripFileExtension();
|
|
|
|
filename.Append( "_local.tga" );
|
|
|
|
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
|
|
|
|
R_VerticalFlip( buffer, width, height );
|
|
|
|
R_WriteTGA( filename, buffer, width, height );
|
|
|
|
|
|
|
|
|
|
|
|
// free the model
|
|
|
|
renderModelManager->FreeModel( highPolyModel );
|
|
|
|
|
|
|
|
// free our work buffer
|
|
|
|
Mem_Free( buffer );
|
|
|
|
Mem_Free( sumBuffer );
|
|
|
|
Mem_Free( colorSumBuffer );
|
|
|
|
|
|
|
|
RestoreWindow();
|
|
|
|
|
|
|
|
// stop updating the screen as we print
|
|
|
|
common->SetRefreshOnPrint( false );
|
|
|
|
|
|
|
|
common->Error( "Completed." );
|
|
|
|
}
|