FWGS
/
hlsdk-xash3d
mirror of https://github.com/FWGS/hlsdk-xash3d
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
hlsdk-xash3d/cl_dll/zx/bumpmap.cpp

1037 lines
30 KiB
C++
Raw Blame History

//
// Bump Mapping in Half-Life
//
// Original code copyright (C) Francis "DeathWish" Woodhouse, 2004.
//
// You are free to use this code in your own projects, so long as
// (a) The original author of this code is credited and
// (b) This header remains intact on both of the main source files
//
// I'd be interested to know if you do decide to use this in something, so I'd
// appreciate it if you drop me a line at deathwish@valve-erc.com if you do.
//
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>
#include <gl/glext.h>
#include <cg/cg.h>
#include <cg/cgGL.h>
#include "hud.h"
#include "cl_util.h"
#include "cvardef.h"
#include "r_studioint.h"
#include "com_model.h"
#include "bumpmap.h"
extern globalvars_t* gpGlobals;
//
// CVARs AVAILABLE
//
// bm_enable 1/0 - enable/disable bumpmapping altogether
// bm_allflat 1/0 - don't use the supplied bumpmaps; render everything as if the surface is flat
//
#define MAX_STYLE_LEN 100
#define NUM_STYLES 12
// every 10th of a second. 'z' is max light, 'a' is darkness
char g_LightStyles[NUM_STYLES][MAX_STYLE_LEN+1] =
{
"z",
"mmnmmommommnonmmonqnmmo",
"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba",
"mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
"mamamamamama",
"jklmnopqrstuvwxyzyxwvutsrqponmlkj",
"nmonqnmomnmomomno",
"mmmaaaabcdefgmmmmaaaammmaamm",
"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
"aaaaaaaazzzzzzzz",
"mmamammmmammamamaaamammma",
"abcdefghijklmnopqrrqponmlkjihgfedcba"
};
// we have to do this to stop the linker complaining, since we're using the evil GLaux
extern "C" long _ftol( double ); //defined by VC6 C libs
extern "C" long _ftol2( double dblSource ) { return _ftol( dblSource ); }
#define M_PI 3.141592653589793238
#define DEG2RAD(d) ((d) * (M_PI / 180))
inline float Clamp(float f, float low, float high)
{
if (f < low)
f = low;
if (f > high)
f = high;
return f;
}
inline Vector RotateX(Vector V, float angle) // angle in degrees
{
Vector ret;
angle = DEG2RAD(angle);
ret.x = V.x;
ret.y = V.y*cos(angle) + V.z*sin(angle);
ret.z = V.z*cos(angle) - V.y*sin(angle);
return ret;
}
inline Vector RotateY(Vector V, float angle) // angle in degrees
{
Vector ret;
angle = DEG2RAD(angle);
ret.x = V.x*cos(angle) - V.z*sin(angle);
ret.y = V.y;
ret.z = V.z*cos(angle) + V.x*sin(angle);
return ret;
}
inline Vector RotateZ(Vector V, float angle) // angle in degrees
{
Vector ret;
angle = DEG2RAD(angle);
ret.x = V.x*cos(angle) + V.y*sin(angle);
ret.y = V.y*cos(angle) - V.x*sin(angle);
ret.z = V.z;
return ret;
}
inline Vector vecNCMVector(int i, int x, int y)
{
float s = ((float)x + 0.5) / BUMP_NORM_CUBE_MAP_SIZE;
float t = ((float)y + 0.5) / BUMP_NORM_CUBE_MAP_SIZE;
float sc = s*2.0 - 1.0;
float tc = t*2.0 - 1.0;
Vector V;
switch (i)
{
case 0:
V.x = 1.0;
V.y = -tc;
V.z = -sc;
break;
case 1:
V.x = -1.0;
V.y = -tc;
V.z = sc;
break;
case 2:
V.x = sc;
V.y = 1.0;
V.z = tc;
break;
case 3:
V.x = sc;
V.y = -1.0;
V.z = -tc;
break;
case 4:
V.x = sc;
V.y = -tc;
V.z = 1.0;
break;
case 5:
V.x = -sc;
V.y = -tc;
V.z = -1.0;
break;
}
V = V.Normalize();
return V;
}
// Global instance of the bumpmap manager
CBumpmapMgr g_BumpmapMgr;
// OpenGL multitexture functions
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB;
PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB;
// OpenGL 3D texture functions
PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT;
bool CBumpmapMgr::Initialise(void)
{
if (m_bInitialised)
Shutdown();
gEngfuncs.pfnRegisterVariable("bm_enable", "0", 0);
gEngfuncs.pfnRegisterVariable("bm_allflat", "0", 0);
m_bFailedInit = true;
if (!IsHardwareCapable())
return false;
if (!InitialiseOGLExtensions())
return false;
if (!CreateSceneTextures())
return false;
if (!LoadBumpTextures())
return false;
if (!InitialiseCg())
return false;
if (!LoadFragmentPrograms())
return false;
m_bInitialised = true;
m_bFailedInit = false;
return true;
}
bool CBumpmapMgr::IsHardwareCapable(void)
{
// Minimum hardware is a GeForce 3 or a Radeon 9500. I don't see the point in making bumpmapping run
// on GeForce 2 or lower - the cards don't have a fast enough fillrate and much texture memory anyway.
// grab the string saying which OpenGL extensions are available on this graphics card
std::string sExtensions;
sExtensions.assign((const char*)glGetString(GL_EXTENSIONS), strlen((const char*)glGetString(GL_EXTENSIONS)));
// check for GL_ARB_multitexture (why the hell are they trying to run this on a Voodoo 2, anyway?)
if (sExtensions.find("GL_ARB_multitexture") == -1)
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not support GL_ARB_multitexture.", "Fatal Error", NULL);
return false;
}
// check for GL_ARB_texture_cube_map
if (sExtensions.find("GL_ARB_texture_cube_map") == -1)
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not support GL_ARB_texture_cube_map.", "Fatal Error", NULL);
return false;
}
// check for GL_NV_texture_rectangle or GL_EXT_texture_rectangle
if (sExtensions.find("GL_NV_texture_rectangle") == -1 && sExtensions.find("GL_EXT_texture_rectangle") == -1)
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not support GL_NV_texture_rectangle or GL_EXT_texture_rectangle.", "Fatal Error", NULL);
return false;
}
// check for GL_EXT_texture3D
if (sExtensions.find("GL_EXT_texture3D") == -1)
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not support GL_EXT_texture3D.", "Fatal Error", NULL);
return false;
}
// see if we have the requisite number of texture units
int iTexUnits;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &iTexUnits);
if (iTexUnits < 4)
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not have four texture units.", "Fatal Error", NULL);
return false;
}
// Check if fragment programs can be run (this'll cull the largest proportion of video cards)
// FP20 = GL_NV_register_combiners and GL_NV_texture_shader
// FP30 = GL_NV_fragment_program
// ARBFP1 = GL_ARB_fragment_program
// There's no GL_ATI_fragment_shader support because Cg doesn't include support for compiling to that target.
// You could write a straight shader in shader ASM, but it isn't really worth it for the few extra cards it'd add
// support for.
if (!cgGLIsProfileSupported(CG_PROFILE_FP20) && !cgGLIsProfileSupported(CG_PROFILE_FP30) && !cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
{
MessageBox(NULL, "Bumpmapping error: Your hardware does not support GL_NV_register_combiners and GL_NV_texture_shader, GL_NV_fragment_program or GL_ARB_fragment_program.", "Fatal Error", NULL);
return false;
}
return true;
}
bool CBumpmapMgr::CreateSceneTextures(void)
{
// create the DIFFUSE scene texture
m_uiDiffuseScene = m_uiNextTexIdx++;
// create the LIGHTMAPPED scene texture
m_uiLightmapScene = m_uiNextTexIdx++;
// create the BUMPMAPPED scene texture
m_uiBumpScene = m_uiNextTexIdx++;
// create the NORMALISATION CUBE MAP
MakeNormCubeMap(&m_uiNormCubeMap);
// create the ATTENUATION MAP
MakeAttenuationMap(&m_uiAttenuationMap);
// create the NORMAL MAP for FLAT SURFACES
MakeFlatNormalMap(&m_uiFlatSurfaceNorm);
return true;
}
bool CBumpmapMgr::LoadBumpTextures(void)
{
char szFile[256];
char szTex[256];
char* pBumpFile;
std::string sMap(gEngfuncs.pfnGetLevelName());
sprintf(szFile, "%s/%s_bump.txt", gEngfuncs.pfnGetGameDirectory(), sMap.substr(0, sMap.rfind('.')).c_str());
FILE* pFile = fopen(szFile, "r");
if (!pFile)
{
// If we can't find the file, just use the flat bumpmap for everything in this map.
return true;
}
model_t* pWorld = gEngfuncs.GetEntityByIndex(0)->model; // worldspawn model
unsigned int uiTex;
char szTexPath[256];
memset(szTex, 0, 256);
// go through each line of the file
while (fgets(szTex, 256, pFile))
{
if (szTex[strlen(szTex)-1] == '\n')
szTex[strlen(szTex)-1] = '\0';
// set pBumpFile to point to the string after the space, and set the space to a null so that szTex only
// references the string before the space
pBumpFile = strchr(szTex, ' ');
*pBumpFile = '\0';
pBumpFile++;
// go through each texinfo in the map
for (int i = 0; i < pWorld->numtexinfo; i++)
{
// we found the texture
if (!_stricmp(pWorld->texinfo[i].texture->name, szTex))
{
sprintf(szTexPath, "%s/detail/%s", gEngfuncs.pfnGetGameDirectory(), pBumpFile);
// load up the specified normal map
if (LoadTexture(szTexPath, &uiTex))
{
// shove it into the map of diffuse texture ID to normal map texture ID
m_aNormalMaps.insert(std::make_pair(pWorld->texinfo[i].texture->gl_texturenum, uiTex));
break;
}
}
}
memset(szTex, 0, 256);
}
fclose(pFile);
return true;
}
bool CBumpmapMgr::InitialiseOGLExtensions(void)
{
// MULTITEXTURE EXTENSIONS
// Used for... well, multitexturing.
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");
if (!glActiveTextureARB)
{
MessageBox(NULL, "Bumpmapping error: Could not acquire pointer to glActiveTextureARB.", "Fatal Error", NULL);
return false;
}
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB");
if (!glMultiTexCoord2fARB)
{
MessageBox(NULL, "Bumpmapping error: Could not acquire pointer to glMultiTexCoord2fARB.", "Fatal Error", NULL);
return false;
}
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)wglGetProcAddress("glMultiTexCoord3fvARB");
if (!glMultiTexCoord3fvARB)
{
MessageBox(NULL, "Bumpmapping error: Could not acquire pointer to glMultiTexCoord3fvARB.", "Fatal Error", NULL);
return false;
}
// 3D TEXTURE EXTENSIONS
// A 3D texture is used for the attenuation map.
glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)wglGetProcAddress("glTexImage3DEXT");
if (!glTexImage3DEXT)
{
MessageBox(NULL, "Bumpmapping error: Could not acquire pointer to glTexImage3DEXT.", "Fatal Error", NULL);
return false;
}
return true;
}
bool CBumpmapMgr::InitialiseCg(void)
{
// create a Cg context
m_cg_Context = cgCreateContext();
if (!m_cg_Context)
{
MessageBox(NULL, "Bumpmapping error: Could not create Cg context!", "Fatal Error", NULL);
return false;
}
// get the best vertex and fragment program profiles
m_cg_vertProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
m_cg_fragProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
return true;
}
bool CBumpmapMgr::LoadFragmentPrograms(void)
{
// fullbright map
if (!LoadCgProgram(&m_fp_Diffuse, m_cg_fragProfile, "render/fp_diffuse.cg"))
{
MessageBox(NULL, "Bumpmapping error: Could not load fp_diffuse.cg!", "Fatal Error", NULL);
return false;
}
// map with only lightmaps
if (!LoadCgProgram(&m_fp_Lightmaps, m_cg_fragProfile, "render/fp_lightmaps.cg"))
{
MessageBox(NULL, "Bumpmapping error: Could not load fp_lightmaps.cg!", "Fatal Error", NULL);
return false;
}
// bumpmapping
if (!LoadCgProgram(&m_fp_Bump, m_cg_fragProfile, "render/fp_bump.cg"))
{
MessageBox(NULL, "Bumpmapping error: Could not load fp_bump.cg!", "Fatal Error", NULL);
return false;
}
// fullbright model
if (!LoadCgProgram(&m_fp_ModelPass0, m_cg_fragProfile, "render/fp_model_p0.cg"))
{
MessageBox(NULL, "Bumpmapping error: Could not load fp_model_p0.cg!", "Fatal Error", NULL);
return false;
}
// model with diffuse colour
if (!LoadCgProgram(&m_fp_ModelPass1, m_cg_fragProfile, "render/fp_model_p1.cg"))
{
MessageBox(NULL, "Bumpmapping error: Could not load fp_model_p1.cg!", "Fatal Error", NULL);
return false;
}
m_parm_BumpLightColour = cgGetNamedParameter(m_fp_Bump, "LightColour");
m_parm_BumpLightStrength = cgGetNamedParameter(m_fp_Bump, "LightStrength");
return true;
}
bool CBumpmapMgr::LoadCgProgram(CGprogram* pDest, CGprofile eProfile, const char* szFile)
{
// map the path
char file[512];
sprintf(file, "%s/%s", gEngfuncs.pfnGetGameDirectory(), szFile);
// load the program
*pDest = cgCreateProgramFromFile(m_cg_Context, CG_SOURCE, file, eProfile, "main", NULL);
if (!(*pDest))
return false;
cgGLLoadProgram(*pDest);
return true;
}
bool CBumpmapMgr::LoadTexture(const char* szFile, unsigned int* pTexIdx)
{
// We're using GLaux for this, because I can't be bothered to code a proper bitmap loading function.
// It works, so no complaining.
// load the image
AUX_RGBImageRec* pImg = auxDIBImageLoad(szFile);
if (!pImg)
return false;
// assign a texture ID and set the various parameters
*pTexIdx = m_uiNextTexIdx++;
glBindTexture(GL_TEXTURE_2D, *pTexIdx);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// load the texture, generating mipmaps for it at the same time
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pImg->sizeX, pImg->sizeY, GL_RGB, GL_UNSIGNED_BYTE, pImg->data);
free(pImg->data);
free(pImg);
return true;
}
void CBumpmapMgr::Shutdown(void)
{
cgDestroyProgram(m_fp_Diffuse);
cgDestroyProgram(m_fp_Lightmaps);
cgDestroyProgram(m_fp_Bump);
cgDestroyProgram(m_fp_ModelPass0);
cgDestroyProgram(m_fp_ModelPass1);
cgDestroyContext(m_cg_Context);
Reset();
}
void CBumpmapMgr::Reset(void)
{
m_iNumFrameLights = 0;
m_bInitialised = false;
m_bFailedInit = false;
m_iLargestVisFrame = 0;
m_aBumpedScenes.clear();
m_aNormalMaps.clear();
}
void CBumpmapMgr::Render(int pass)
{
if (!m_bInitialised && !m_bFailedInit)
Initialise();
if (CVAR_GET_FLOAT("bm_enable") == 0 || g_BumpmapMgr.m_bFailedInit)
return;
int i;
// We must clear to black to enable non-bumpmapped items to be re-combined with the scene properly,
// and also to enable us to just render the bump mapping with additive blending for every light.
glClearColor(0,0,0,1);
m_iCurPass = pass;
switch (pass)
{
case 0:
// Render the scene with only the DIFFUSE COLOUR (fullbright)
cgGLEnableProfile(m_cg_fragProfile);
cgGLBindProgram(m_fp_Diffuse);
break;
case 1:
// In pass 0, we rendered the scene with just the diffuse texture. Grab this to a texture.
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiDiffuseScene);
glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, ScreenWidth, ScreenHeight, 0);
// Here is the best time to render the bump-mapped scenes. We make use of the existing z-buffer data
// to (a) stop us having to update the z-buffer and (b) to create black "holes" where items
// such as models and brush entities go.
glClear(GL_COLOR_BUFFER_BIT); // clear the colour buffer, but NOT the depth buffer
glDepthMask(GL_FALSE); // disable modification of the depth buffer
glDepthFunc(GL_LEQUAL);
// Each light adds its contribution to the rest
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
for (i = 0; i < m_aBumpedScenes.size(); i++)
{
RenderLight(i);
}
glDisable(GL_BLEND);
glDepthMask(GL_TRUE); // re-enable modification of the depth buffer
glDepthFunc(GL_LESS);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiBumpScene);
glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, ScreenWidth, ScreenHeight, 0);
glDisable(GL_TEXTURE_RECTANGLE_NV);
glClear(GL_COLOR_BUFFER_BIT);
// We now render the scene with just the LIGHTMAPS.
cgGLBindProgram(m_fp_Lightmaps);
break;
case 2:
// In pass 1, we rendered the scene with just the lightmaps. Grab this to a texture.
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiLightmapScene);
glCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGB, 0, 0, ScreenWidth, ScreenHeight, 0);
// Fragment programs aren't needed any more.
cgGLDisableProfile(m_cg_fragProfile);
// Switch to an orthogonal projection to render full-screen quads and combine all the scenes
// together to give the final result.
DoOrthoProjection(true);
CombineScenes();
DoOrthoProjection(false);
break;
default:
gEngfuncs.Con_Printf("BUMPMAPPING: Unknown pass number %i passed to Render\n", pass);
}
}
void CBumpmapMgr::RenderLight(int light)
{
// get a ptr to the light in question
bumplight_t* pLight = &m_aBumpedScenes[light];
if (!pLight->enabled)
return;
// calculate the movewith
if (pLight->moveWithEnt)
{
// first, adjust the light's position by any change that the movewith entity has undergone
pLight->pos = pLight->origPos + (pLight->moveWithEnt->origin - pLight->entOrigPos);
// rotate the light around the movewith entity by any change in its angles
Vector anglesChange = pLight->moveWithEnt->angles - pLight->entOrigAngles;
Vector newPos = pLight->pos - pLight->moveWithEnt->origin;
newPos = RotateZ(newPos, -anglesChange.y);
newPos = RotateY(newPos, -anglesChange.x);
newPos = RotateX(newPos, -anglesChange.z);
newPos = newPos + pLight->moveWithEnt->origin;
pLight->pos = newPos;
}
float styleStrength = (float)(g_LightStyles[pLight->style][(int)(gpGlobals->time * 10) % strlen(g_LightStyles[pLight->style])] - 'a') / ('z' - 'a');
if (styleStrength == 0)
return;
// bind the right fragment program and set the parameters
cgGLBindProgram(m_fp_Bump);
cgGLSetParameter1f(m_parm_BumpLightStrength, pLight->strength * styleStrength);
cgGLSetParameter3fv(m_parm_BumpLightColour, pLight->colour);
// bind the normalisation cube map to tex unit 1
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_RECTANGLE_NV);
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, m_uiNormCubeMap);
// bind the attenuation map to tex unit 2
glActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_3D_EXT);
glBindTexture(GL_TEXTURE_3D_EXT, m_uiAttenuationMap);
// normal maps will be bound to tex unit 0
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_RECTANGLE_NV);
glEnable(GL_TEXTURE_2D);
// create a bunch of variables
model_t* pWorld = gEngfuncs.GetEntityByIndex(0)->model; // worldspawn model
msurface_t** pSurf = pWorld->marksurfaces; // ptr to array of surfaces
glpoly_t* pPoly;
Vector N, T, B, L, L2, V, V1, V2, V3, E1, E2, AttenCoords;
TexNormalMaps_It texID;
glShadeModel(GL_SMOOTH);
// go through each surface
for (int i = 0; i < pWorld->nummarksurfaces; i++)
{
// This is a semi-hack to use the pre-calculated visibilty info. We don't have access
// to what the current visframe is, but we can assume that the surfaces with the highest
// visframe are those which are currently being rendered. If the visframe changes, then
// there might be more overdraw for one frame, but this isn't noticeable.
//
// To stop surfaces being rendered twice (which is disastrous, since we are using additive
// blending) we set the visframe to the negative value of itself once we've rendered the surface.
// If we then find a surface that has a negative visframe, we know that we've already
// rendered that one.
if (pSurf[i]->visframe > 0 && pSurf[i]->visframe >= m_iLargestVisFrame)
{
m_iLargestVisFrame = pSurf[i]->visframe;
pPoly = pSurf[i]->polys;
float* vert = pPoly->verts[0];
// find the normal map corresponding to this surface's texture (use the flat map if there isn't one)
texID = m_aNormalMaps.find(pSurf[i]->texinfo->texture->gl_texturenum);
if (CVAR_GET_FLOAT("bm_allflat") == 1 || texID == m_aNormalMaps.end())
glBindTexture(GL_TEXTURE_2D, m_uiFlatSurfaceNorm);
else
glBindTexture(GL_TEXTURE_2D, texID->second);
// tangent and binormal simply come from the UV vectors
T = pSurf[i]->texinfo->vecs[0];
B = pSurf[i]->texinfo->vecs[1];
T = T.Normalize();
B = B.Normalize();
// We must now calculate the normal of the surface. We can't cross-product the tangent and binormal,
// as we can't guarantee which way the normal will be facing (textures can be mirrored both ways).
// So, we must calculate it by doing the cross product of two edge vectors. However, we can't just
// choose any old edge vectors, since some turn out to be colinear, which gives bogus normals.
// The solution is to go through each vertex until we find two edge vectors that aren't colinear.
V1 = Vector(vert[0], vert[1], vert[2]);
V2 = Vector(vert[VERTEXSIZE], vert[VERTEXSIZE+1], vert[VERTEXSIZE+2]);
E1 = (V1 - V2).Normalize();
bool bFound = false;
for (int j = 2; j < pPoly->numverts; j++)
{
V3 = Vector(vert[VERTEXSIZE*j], vert[VERTEXSIZE*j + 1], vert[VERTEXSIZE*j + 2]);
E2 = (V1 - V3).Normalize();
if (fabs(fabs(DotProduct(E1, E2))-1) > 0.01f) // vectors aren't colinear (dp 1 = equal, dp -1 = opposite) - check for > epsilon to account for FP error
{
N = -1 * CrossProduct(E1, E2).Normalize(); // we can use these edge vectors to calculate the normal
bFound = true;
break;
}
}
if (!bFound)
N = -1 * CrossProduct(E1, (V1 - Vector(vert + VERTEXSIZE*2)).Normalize()).Normalize();
// render this surface
glBegin(GL_POLYGON);
for (int v = 0; v < pPoly->numverts; v++, vert+=VERTEXSIZE)
{
// Since we can't use a vertex program, we have to calculate the light vector here. We first
// calculate the light vector in world space, and then transform it into tangent space
// by doing the equivalent of multiplying it by the TBN matrix, and finally scale it into the range [0,1].
V = Vector(vert);
L = pLight->pos - V;
L2.x = DotProduct(T, L)*0.5 + 0.5;
L2.y = -DotProduct(B, L)*0.5 + 0.5; // for some reason, the y component of the light vector must be flipped - probably a by-product of the normal maps being flipped on loading
L2.z = DotProduct(N, L)*0.5 + 0.5;
// We also have to calculate the coordinates in the attenuation texture
AttenCoords = (L / (pLight->radius * 2)) + Vector(0.5,0.5,0.5);
// send the data to OGL
glTexCoord2f(vert[3], 1 - vert[4]); // the normal maps get flipped on loading, for some reason - reverse that here
glMultiTexCoord3fvARB(GL_TEXTURE1_ARB, L2);
glMultiTexCoord3fvARB(GL_TEXTURE2_ARB, AttenCoords);
glVertex3fv(vert);
}
glEnd();
}
// set the negative visframe to say we've rendered this surface
if (pSurf[i]->visframe > 0)
pSurf[i]->visframe = -pSurf[i]->visframe;
}
// go back and make all visframes positive again, so that HL can render the map properly
for (i = 0; i < pWorld->nummarksurfaces; i++)
{
if (pSurf[i]->visframe < 0)
pSurf[i]->visframe = -pSurf[i]->visframe;
}
glActiveTextureARB(GL_TEXTURE2_ARB);
glDisable(GL_TEXTURE_3D_EXT);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void CBumpmapMgr::CombineScenes(void)
{
// find out how many texture units we've got to mess with
int iTexUnits;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &iTexUnits);
// Add together the lightmap and the bump mapping, and modulate this by the textures
for (int i = 0; i < iTexUnits; i++)
{
glActiveTextureARB(GL_TEXTURE0_ARB + i);
glDisable(GL_TEXTURE_RECTANGLE_NV);
glDisable(GL_TEXTURE_2D);
}
glColor4f(1,1,1,1);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiLightmapScene);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiBumpScene);
glActiveTextureARB(GL_TEXTURE2_ARB);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_RECTANGLE_NV);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_RECTANGLE_NV, m_uiDiffuseScene);
RenderScreenQuad((float)ScreenWidth, (float)ScreenHeight, iTexUnits);
// Clean up - de-activate texturing on all units (except the first one, on which
// we enable regular 2D texturing, since HL doesn't do this...)
for (i = 0; i < iTexUnits; i++)
{
glActiveTextureARB(GL_TEXTURE0_ARB + i);
glDisable(GL_TEXTURE_RECTANGLE_NV);
}
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
void CBumpmapMgr::RenderScreenQuad(float texU, float texV, int iNumTexUnits)
{
int i;
glBegin(GL_QUADS);
for (i = 0; i < iNumTexUnits; i++) glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, 0, texV);
glVertex2f(0,0);
for (i = 0; i < iNumTexUnits; i++) glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, texU, texV);
glVertex2f(1,0);
for (i = 0; i < iNumTexUnits; i++) glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, texU, 0);
glVertex2f(1,1);
for (i = 0; i < iNumTexUnits; i++) glMultiTexCoord2fARB(GL_TEXTURE0_ARB + i, 0, 0);
glVertex2f(0,1);
glEnd();
}
void CBumpmapMgr::DoOrthoProjection(bool activate)
{
if (activate)
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, 1, 1, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
else
{
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
}
void CBumpmapMgr::AddLight(const char* targetname, Vector pos, Vector colour, float strength, float radius,
bool enabled /*= true*/, int style /*= 0*/, int moveWithEntID /*= -1*/, bool moveWithExtraInfo /*= false*/,
Vector moveWithEntPos, Vector moveWithEntAngles)
{
bumplight_t light;
light.enabled = enabled;
light.pos = pos;
light.origPos = pos;
light.colour = colour;
light.strength = strength;
light.radius = radius;
light.style = (style >= NUM_STYLES ? 0 : style);
memset(light.targetname, 0, 64);
memcpy(light.targetname, targetname, strlen(targetname));
if (moveWithEntID == -1)
light.moveWithEnt = NULL;
else
{
light.moveWithEnt = gEngfuncs.GetEntityByIndex(moveWithEntID);
if (light.moveWithEnt != NULL)
{
if (moveWithExtraInfo)
{
light.entOrigPos = moveWithEntPos;
light.entOrigAngles = moveWithEntAngles;
}
else
{
light.entOrigPos = light.moveWithEnt->origin;
light.entOrigAngles = light.moveWithEnt->angles;
}
}
}
m_aBumpedScenes.push_back(light);
m_iNumFrameLights++;
}
void CBumpmapMgr::EnableLight(const char* targetname, bool enable)
{
for (BumpSceneList_It it = m_aBumpedScenes.begin(); it != m_aBumpedScenes.end(); ++it)
{
if (!_stricmp(targetname, it->targetname))
it->enabled = enable;
}
}
void CBumpmapMgr::RenderStudioModel(bool bPreRender)
{
if (CVAR_GET_FLOAT("bm_enable") == 0 || g_BumpmapMgr.m_bFailedInit)
return;
// bPreRender is true before rendering a studio model, false afterwards
if (bPreRender)
{
if (m_iCurPass == 0)
cgGLBindProgram(m_fp_ModelPass0);
else
cgGLBindProgram(m_fp_ModelPass1);
}
else
{
if (m_iCurPass == 0)
cgGLBindProgram(m_fp_Diffuse);
else
cgGLBindProgram(m_fp_Lightmaps);
}
}
void CBumpmapMgr::MakeNormCubeMap(unsigned int* pTexIdx)
{
unsigned char* pTex = new unsigned char[BUMP_NORM_CUBE_MAP_SIZE*BUMP_NORM_CUBE_MAP_SIZE*3];
*pTexIdx = m_uiNextTexIdx++;
// set the texture's parameters
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, *pTexIdx);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
Vector V;
// For each face of the cube map, generate a flat texture that gives a normalised version of the
// vector used to access that texel in the cube texture.
for (int i = 0; i < 6; i++)
{
for (int y = 0; y < BUMP_NORM_CUBE_MAP_SIZE; y++)
{
for (int x = 0; x < BUMP_NORM_CUBE_MAP_SIZE; x++)
{
V = vecNCMVector(i, x, y);
pTex[(x + y*BUMP_NORM_CUBE_MAP_SIZE)*3] = (unsigned char)((V.x * 0.5 + 0.5)*255);
pTex[(x + y*BUMP_NORM_CUBE_MAP_SIZE)*3+1] = (unsigned char)((V.y * 0.5 + 0.5)*255);
pTex[(x + y*BUMP_NORM_CUBE_MAP_SIZE)*3+2] = (unsigned char)((V.z * 0.5 + 0.5)*255);
}
}
// store this face's image
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + i, 0, 3, BUMP_NORM_CUBE_MAP_SIZE, BUMP_NORM_CUBE_MAP_SIZE,
0, GL_RGB, GL_UNSIGNED_BYTE, pTex);
}
delete[] pTex;
}
void CBumpmapMgr::MakeAttenuationMap(unsigned int* pTexIdx)
{
unsigned char* pTex = new unsigned char[BUMP_ATTENUATION_MAP_SIZE*BUMP_ATTENUATION_MAP_SIZE*BUMP_ATTENUATION_MAP_SIZE];
*pTexIdx = m_uiNextTexIdx++;
glBindTexture(GL_TEXTURE_3D_EXT, *pTexIdx);
glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_CLAMP);
glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP);
Vector V;
// For each texel in the attenuation map, calculate x^2 + y^2 + z^2 and store it, clamping to [0,1].
for (int z = 0; z < BUMP_ATTENUATION_MAP_SIZE; z++)
{
for (int y = 0; y < BUMP_ATTENUATION_MAP_SIZE; y++)
{
for (int x = 0; x < BUMP_ATTENUATION_MAP_SIZE; x++)
{
V = Vector(((float)x / BUMP_ATTENUATION_MAP_SIZE) * 2 - 1,
((float)y / BUMP_ATTENUATION_MAP_SIZE) * 2 - 1,
((float)z / BUMP_ATTENUATION_MAP_SIZE) * 2 - 1) * 1.05;
pTex[x + y*BUMP_ATTENUATION_MAP_SIZE + z*BUMP_ATTENUATION_MAP_SIZE*BUMP_ATTENUATION_MAP_SIZE] = (unsigned char)Clamp((V.x*V.x + V.y*V.y + V.z*V.z) * 255, 0, 255);
}
}
}
// load the texture data
glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_RGB, BUMP_ATTENUATION_MAP_SIZE, BUMP_ATTENUATION_MAP_SIZE, BUMP_ATTENUATION_MAP_SIZE,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pTex);
delete[] pTex;
}
void CBumpmapMgr::MakeFlatNormalMap(unsigned int* pTexIdx)
{
*pTexIdx = m_uiNextTexIdx++;
glBindTexture(GL_TEXTURE_2D, *pTexIdx);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
unsigned char pTex[1*1*3]; // it doesn't need any clarity, seeing as it's all one colour - just make it 1x1
pTex[0] = 128; // unpacked, this gives 0
pTex[1] = 128; // unpacked, this gives 0
pTex[2] = 255; // unpacked, this gives 1
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, pTex);
}
Reference in New Issue View Git Blame Copy Permalink