BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/engine/disp.cpp

1130 lines
34 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//===========================================================================//
#include "render_pch.h"
#include "gl_cvars.h"
#include "gl_model_private.h"
#include "gl_lightmap.h"
#include "disp.h"
#include "mathlib/mathlib.h"
#include "gl_rsurf.h"
#include "gl_matsysiface.h"
#include "zone.h"
#include "materialsystem/imesh.h"
#include "iscratchpad3d.h"
#include "decal_private.h"
#include "con_nprint.h"
#include "dispcoll_common.h"
#include "cmodel_private.h"
#include "collisionutils.h"
#include "tier0/dbg.h"
#include "gl_rmain.h"
#include "lightcache.h"
#include "disp_tesselate.h"
#include "shadowmgr.h"
#include "debugoverlay.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Globals.
//-----------------------------------------------------------------------------
Vector modelorg;
ConVar r_DispDrawAxes( "r_DispDrawAxes", "0" );
//-----------------------------------------------------------------------------
// CEngineTesselateHelper implements the abstract parts of the tesselation code.
// We're only interested in the final triangles anyway, right??
//-----------------------------------------------------------------------------
class CEngineTesselateHelper : public CBaseTesselateHelper
{
public:
void EndTriangle()
{
// Put all triangles in here.
int iVertOffset = m_pDisp->m_iVertOffset;
// Add this tri to our mesh.
m_IndexMesh.Index( m_TempIndices[0] + iVertOffset );
m_IndexMesh.AdvanceIndex();
m_IndexMesh.Index( m_TempIndices[1] + iVertOffset );
m_IndexMesh.AdvanceIndex();
m_IndexMesh.Index( m_TempIndices[2] + iVertOffset );
m_IndexMesh.AdvanceIndex();
// Store off the indices...
m_pDisp->m_Indices[m_nIndices] = m_TempIndices[0] + iVertOffset;
m_pDisp->m_Indices[m_nIndices+1] = m_TempIndices[1] + iVertOffset;
m_pDisp->m_Indices[m_nIndices+2] = m_TempIndices[2] + iVertOffset;
m_nIndices += 3;
}
DispNodeInfo_t& GetNodeInfo( int iNodeBit )
{
return m_pDisp->m_pNodeInfo[iNodeBit];
}
public:
// The mesh that we specify indices into while tesselating.
CMeshBuilder m_IndexMesh;
CDispInfo *m_pDisp;
};
//-----------------------------------------------------------------------------
// CDispInfo implementation.
//-----------------------------------------------------------------------------
inline CVertIndex CDispInfo::IndexToVert( int index ) const
{
if( index == -1 )
return CVertIndex( -1, -1 );
else
return CVertIndex( index % GetSideLength(), index / GetSideLength() );
}
void CDispInfo::UpdateBoundingBox()
{
m_BBoxMin.Init( 1e24, 1e24, 1e24 );
m_BBoxMax.Init( -1e24, -1e24, -1e24 );
for( int i=0; i < NumVerts(); i++ )
{
const Vector &pos = m_MeshReader.Position( i );
VectorMin( pos, m_BBoxMin, m_BBoxMin );
VectorMax( pos, m_BBoxMax, m_BBoxMax );
}
}
inline void CDispInfo::DecalProjectVert( Vector const &vPos, CDispDecalBase *pDecalBase, ShadowInfo_t const* pInfo, Vector &out )
{
if (!pInfo)
{
CDispDecal* pDispDecal = static_cast<CDispDecal*>(pDecalBase);
out.x = vPos.Dot( pDispDecal->m_TextureSpaceBasis[0] ) - pDispDecal->m_pDecal->dx + .5f;
out.y = vPos.Dot( pDispDecal->m_TextureSpaceBasis[1] ) - pDispDecal->m_pDecal->dy + .5f;
out.z = 0;
}
else
{
Vector3DMultiplyPosition( pInfo->m_WorldToShadow, vPos, out );
}
}
// ----------------------------------------------------------------------------- //
// This version works for normal decals
// ----------------------------------------------------------------------------- //
void CDispInfo::TestAddDecalTri( int iIndexStart, unsigned short decalHandle, CDispDecal *pDispDecal )
{
decal_t *pDecal = pDispDecal->m_pDecal;
// If the decal is too far away from the plane of this triangle, reject it.
unsigned short tempIndices[3] =
{
(unsigned short)(m_MeshReader.Index( iIndexStart+0 ) - m_iVertOffset),
(unsigned short)(m_MeshReader.Index( iIndexStart+1 ) - m_iVertOffset),
(unsigned short)(m_MeshReader.Index( iIndexStart+2 ) - m_iVertOffset)
};
const Vector &v0 = m_MeshReader.Position( tempIndices[0] );
const Vector &v1 = m_MeshReader.Position( tempIndices[1] );
const Vector &v2 = m_MeshReader.Position( tempIndices[2] );
Vector vNormal = (v2 - v0).Cross( v1 - v0 );
VectorNormalize( vNormal );
if ( vNormal.Dot( pDecal->position - v0 ) >= pDispDecal->m_flSize )
return;
// Setup verts.
CDecalVert verts[3];
int iVert;
for( iVert=0; iVert < 3; iVert++ )
{
CDecalVert *pOutVert = &verts[iVert];
pOutVert->m_vPos = m_MeshReader.Position( tempIndices[iVert] );
{
float x = pOutVert->m_cLMCoords.x;
float y = pOutVert->m_cLMCoords.y;
m_MeshReader.TexCoord2f( tempIndices[iVert], 1, x, y );
pOutVert->m_cLMCoords.x = x;
pOutVert->m_cLMCoords.y = y;
}
// garymcthack - what about m_ParentTexCoords?
Vector tmp;
DecalProjectVert( pOutVert->m_vPos, pDispDecal, 0, tmp );
pOutVert->m_ctCoords.x = tmp.x;
pOutVert->m_ctCoords.y = tmp.y;
}
// Clip them.
CDecalVert *pClipped;
CDecalVert *pOutVerts = NULL;
pClipped = R_DoDecalSHClip( &verts[0], pOutVerts, pDecal, 3, vec3_origin );
int outCount = pDecal->clippedVertCount;
if ( outCount > 2 )
{
outCount = min( outCount, (int)CDispDecalFragment::MAX_VERTS );
// Allocate a new fragment...
CDispDecalFragment* pFragment = AllocateDispDecalFragment( decalHandle, outCount );
// Alrighty, store the triangles!
for( iVert=0; iVert < outCount; iVert++ )
{
pFragment->m_pVerts[iVert].m_vPos = pClipped[iVert].m_vPos;
// garymcthack - need to make this work for displacements
// pFragment->m_tCoords[iVert] = pClipped[iVert].m_tCoords;
// garymcthack - need to change m_TCoords to m_ParentTexCoords
pFragment->m_pVerts[iVert].m_ctCoords = pClipped[iVert].m_ctCoords;
pFragment->m_pVerts[iVert].m_cLMCoords = pClipped[iVert].m_cLMCoords;
}
/*
static int three = 0;
static int total = 0;
total++;
if( outCount == 3 )
{
three++;
}
//if( )
{
char buffer[256];
sprintf(buffer, "Verts: 3:%i 4+:%i (%i)\n",three, total, sizeof(CDecalVert));
Msg(buffer);
}
*/
pFragment->m_pDecal = pDecal;
pFragment->m_nVerts = outCount;
pDispDecal->m_nVerts += pFragment->m_nVerts;
pDispDecal->m_nTris += pFragment->m_nVerts - 2;
}
}
// ----------------------------------------------------------------------------- //
// This version works for shadow decals
// ----------------------------------------------------------------------------- //
void CDispInfo::TestAddDecalTri( int iIndexStart, unsigned short decalHandle, CDispShadowDecal *pDecal )
{
unsigned short tempIndices[3] =
{
(unsigned short)(m_MeshReader.Index( iIndexStart+0 ) - m_iVertOffset),
(unsigned short)(m_MeshReader.Index( iIndexStart+1 ) - m_iVertOffset),
(unsigned short)(m_MeshReader.Index( iIndexStart+2 ) - m_iVertOffset)
};
#ifndef SWDS
// Setup verts.
Vector vPositions[3] ={
GetOverlayPos( &m_MeshReader, tempIndices[0] ),
GetOverlayPos( &m_MeshReader, tempIndices[1] ),
GetOverlayPos( &m_MeshReader, tempIndices[2] )
};
Vector* ppPosition[3] = { &vPositions[0], &vPositions[1], &vPositions[2] };
ShadowVertex_t** ppClipVertex;
int count = g_pShadowMgr->ProjectAndClipVertices( pDecal->m_Shadow, 3, ppPosition, &ppClipVertex );
if (count < 3)
return;
// Ok, clipping happened; lets create a decal fragment.
Assert( count <= CDispShadowFragment::MAX_VERTS );
// Allocate a new fragment...
CDispShadowFragment* pFragment = AllocateShadowDecalFragment( decalHandle, count );
// Copy the fragment data in place
pFragment->m_nVerts = count;
for (int i = 0; i < count; ++i )
{
VectorCopy( ppClipVertex[i]->m_Position, pFragment->m_ShadowVerts[i].m_Position );
VectorCopy( ppClipVertex[i]->m_ShadowSpaceTexCoord, pFragment->m_ShadowVerts[i].m_ShadowSpaceTexCoord );
// Make sure it's been clipped
Assert( pFragment->m_ShadowVerts[i].m_ShadowSpaceTexCoord[0] >= -1e-3f );
Assert( pFragment->m_ShadowVerts[i].m_ShadowSpaceTexCoord[0] - 1.0f <= 1e-3f );
Assert( pFragment->m_ShadowVerts[i].m_ShadowSpaceTexCoord[1] >= -1e-3f );
Assert( pFragment->m_ShadowVerts[i].m_ShadowSpaceTexCoord[1] - 1.0f <= 1e-3f );
}
// Update the number of triangles in the decal
pDecal->m_nVerts += pFragment->m_nVerts;
pDecal->m_nTris += pFragment->m_nVerts - 2;
Assert( pDecal->m_nTris != 0 );
#endif
}
void CDispInfo::CullDecals(
int iNodeBit,
CDispDecal **decals,
int nDecals,
CDispDecal **childDecals,
int &nChildDecals )
{
// Only let the decals through that can affect this node or its children.
nChildDecals = 0;
for( int iDecal=0; iDecal < nDecals; iDecal++ )
{
if( decals[iDecal]->m_NodeIntersect.Get( iNodeBit ) )
{
childDecals[nChildDecals] = decals[iDecal];
++nChildDecals;
}
}
}
//-----------------------------------------------------------------------------
// Retesselates a displacement
//-----------------------------------------------------------------------------
void CDispInfo::TesselateDisplacement()
{
// Clear decals. They get regenerated in TesselateDisplacement_R.
ClearAllDecalFragments();
// Blow away cached shadow decals
ClearAllShadowDecalFragments();
int nMaxIndices = Square( GetSideLength() - 1 ) * 6;
CEngineTesselateHelper helper;
helper.m_pDisp = this;
helper.m_IndexMesh.BeginModify( m_pMesh->m_pMesh, 0, 0, m_iIndexOffset, nMaxIndices );
helper.m_pActiveVerts = m_ActiveVerts.Base();
helper.m_pPowerInfo = GetPowerInfo();
// Generate the indices.
::TesselateDisplacement<CEngineTesselateHelper>( &helper ); // (implemented in disp_tesselate.h)
helper.m_IndexMesh.EndModify();
m_nIndices = helper.m_nIndices;
}
void CDispInfo::SpecifyDynamicMesh()
{
CMatRenderContextPtr pRenderContext( materials );
// Specify the vertices and indices.
IMesh *pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_TRIANGLES, NumVerts(), m_nIndices );
// This should mirror how FillStaticBuffer works.
int nVerts = NumVerts();
for( int iVert=0; iVert < nVerts; iVert++ )
{
CDispRenderVert *pVert = &m_Verts[iVert];
builder.Position3fv( pVert->m_vPos.Base() );
builder.TexCoord2fv( 0, pVert->m_vTexCoord.Base() );
builder.TexCoord2fv( 1, pVert->m_LMCoords.Base() );
builder.TexCoord2f( 2, m_BumpSTexCoordOffset, 0 );
builder.Normal3fv( pVert->m_vNormal.Base() );
builder.TangentS3fv( pVert->m_vSVector.Base() );
builder.TangentT3fv( pVert->m_vTVector.Base() );
builder.AdvanceVertex();
}
for( int iIndex=0; iIndex < m_nIndices; iIndex++ )
{
builder.Index( m_Indices[iIndex] - m_iVertOffset );
builder.AdvanceIndex();
}
builder.End( false, true );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDispInfo::SpecifyWalkableDynamicMesh( void )
{
// Specify the vertices and indices.
CMatRenderContextPtr pRenderContext( materials );
#ifdef SWDS
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, NULL );
#else
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_materialTranslucentSingleColor );
g_materialTranslucentSingleColor->ColorModulate( 1.0f, 1.0f, 0.0f );
g_materialTranslucentSingleColor->AlphaModulate( 0.33f );
#endif
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_TRIANGLES, NumVerts(), m_nWalkIndexCount );
int nVerts = NumVerts();
for( int iVert=0; iVert < nVerts; iVert++ )
{
builder.Position3fv( m_Verts[iVert].m_vPos.Base() );
builder.AdvanceVertex();
}
for( int iIndex=0; iIndex < m_nWalkIndexCount; iIndex++ )
{
builder.Index( m_pWalkIndices[iIndex] );
builder.AdvanceIndex();
}
builder.End( false, true );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDispInfo::SpecifyBuildableDynamicMesh( void )
{
// Specify the vertices and indices.
CMatRenderContextPtr pRenderContext( materials );
#ifdef SWDS
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, NULL );
#else
g_materialTranslucentSingleColor->ColorModulate( 0.0f, 1.0f, 1.0f );
g_materialTranslucentSingleColor->AlphaModulate( 0.33f );
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_materialTranslucentSingleColor );
#endif
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_TRIANGLES, NumVerts(), m_nBuildIndexCount );
int nVerts = NumVerts();
for( int iVert=0; iVert < nVerts; iVert++ )
{
builder.Position3fv( m_Verts[iVert].m_vPos.Base() );
builder.AdvanceVertex();
}
for( int iIndex=0; iIndex < m_nBuildIndexCount; iIndex++ )
{
builder.Index( m_pBuildIndices[iIndex] );
builder.AdvanceIndex();
}
builder.End( false, true );
}
void CDispInfo::InitializeActiveVerts()
{
// Mark the corners vertices and root node by default..
m_ActiveVerts.ClearAll();
m_ActiveVerts.Set( VertIndex( 0, 0 ) );
m_ActiveVerts.Set( VertIndex( GetSideLength()-1, 0 ) );
m_ActiveVerts.Set( VertIndex( GetSideLength()-1, GetSideLength()-1 ) );
m_ActiveVerts.Set( VertIndex( 0, GetSideLength()-1 ) );
m_ActiveVerts.Set( VertIndex( m_pPowerInfo->m_RootNode ) );
// Force the midpoint active on any edges where there are sub displacements.
for( int iSide=0; iSide < 4; iSide++ )
{
CDispNeighbor *pSide = &m_EdgeNeighbors[iSide];
if( (pSide->m_SubNeighbors[0].IsValid() && pSide->m_SubNeighbors[0].m_Span != CORNER_TO_CORNER) ||
(pSide->m_SubNeighbors[1].IsValid() && pSide->m_SubNeighbors[1].m_Span != CORNER_TO_CORNER) )
{
int iEdgeDim = g_EdgeDims[iSide];
CVertIndex nodeIndex;
nodeIndex[iEdgeDim] = g_EdgeSideLenMul[iSide] * m_pPowerInfo->m_SideLengthM1;
nodeIndex[!iEdgeDim] = m_pPowerInfo->m_MidPoint;
m_ActiveVerts.Set( VertIndex( nodeIndex ) );
}
}
}
void CDispInfo::ClearLOD()
{
// First, everything as inactive.
m_ActiveVerts.ClearAll();
}
extern ConVar mat_surfaceid;
extern ConVar mat_surfacemat;
bool DispInfoRenderDebugModes()
{
if( ShouldDrawInWireFrameMode() || mat_luxels.GetInt() || r_DispWalkable.GetInt() ||
r_DispBuildable.GetInt()
#if !defined( SWDS )
|| mat_surfaceid.GetInt() || mat_surfacemat.GetInt()
#endif // SWDS
)
return true;
return false;
}
bool CDispInfo::Render( CGroupMesh *pGroup, bool bAllowDebugModes )
{
#ifndef SWDS
if( !m_pMesh )
{
Assert( !"CDispInfo::Render: m_pMesh == NULL" );
return false;
}
// Trivial reject?
if( R_CullBox(m_BBoxMin, m_BBoxMax, g_Frustum) )
return false;
bool bNormalRender = true;
if ( bAllowDebugModes )
{
CMatRenderContextPtr pRenderContext( materials );
// Wireframe?
if( ShouldDrawInWireFrameMode() )
{
pRenderContext->Bind( g_materialWireframe );
SpecifyDynamicMesh();
bNormalRender = false;
}
if( mat_luxels.GetInt() )
{
pRenderContext->Bind( MSurf_TexInfo( m_ParentSurfID )->material );
//SpecifyDynamicMesh();
pGroup->m_pMesh->Draw( m_iIndexOffset, m_nIndices );
pRenderContext->Bind( g_materialDebugLuxels );
SpecifyDynamicMesh();
bNormalRender = false;
}
if ( r_DispWalkable.GetInt() || r_DispBuildable.GetInt() )
{
pRenderContext->Bind( MSurf_TexInfo( m_ParentSurfID )->material );
pGroup->m_pMesh->Draw( m_iIndexOffset, m_nIndices );
if ( r_DispWalkable.GetInt() )
SpecifyWalkableDynamicMesh();
if ( r_DispBuildable.GetInt() )
SpecifyBuildableDynamicMesh();
bNormalRender = false;
}
#if !defined( SWDS )
if ( mat_surfaceid.GetInt() )
{
Vector bbMin, bbMax, vecCenter;
GetBoundingBox( bbMin, bbMax );
VectorAdd( bbMin, bbMax, vecCenter );
vecCenter *= 0.5f;
int nInt = ( mat_surfaceid.GetInt() != 2 ) ? (int)m_ParentSurfID : (msurface2_t*)m_ParentSurfID - host_state.worldbrush->surfaces2;
char buf[32];
Q_snprintf( buf, sizeof( buf ), "%d", nInt );
CDebugOverlay::AddTextOverlay( vecCenter, 0, buf );
}
if ( mat_surfacemat.GetInt() )
{
Vector bbMin, bbMax, vecCenter;
GetBoundingBox( bbMin, bbMax );
VectorAdd( bbMin, bbMax, vecCenter );
vecCenter *= 0.5f;
mtexinfo_t * pTexInfo = MSurf_TexInfo(m_ParentSurfID);
const char *pFullMaterialName = pTexInfo->material ? pTexInfo->material->GetName() : "no material";
const char *pSlash = strrchr( pFullMaterialName, '/' );
const char *pMaterialName = strrchr( pFullMaterialName, '\\' );
if (pSlash > pMaterialName)
pMaterialName = pSlash;
if (pMaterialName)
++pMaterialName;
else
pMaterialName = pFullMaterialName;
CDebugOverlay::AddTextOverlay( vecCenter, 0, pMaterialName );
}
#endif // SWDS
}
// Mark it visible.
if( bNormalRender )
{
if( pGroup->m_nVisible < pGroup->m_Visible.Size() )
{
// Don't bother if all faces are backfacing, or somesuch...
if (m_nIndices)
{
pGroup->m_Visible[pGroup->m_nVisible].m_FirstIndex = m_iIndexOffset;
pGroup->m_Visible[pGroup->m_nVisible].m_NumIndices = m_nIndices;
pGroup->m_VisibleDisps[pGroup->m_nVisible] = this;
pGroup->m_nVisible++;
pGroup->m_pGroup->m_nVisible++;
}
}
else
{
Assert( !"Overflowed visible mesh list" );
}
}
#endif
return true;
}
struct ProcessLightmapSampleData_t;
typedef void ProcessLightmapSampleFunc_t( const ProcessLightmapSampleData_t &data, const Vector &vPos, const Vector &vNormal, const Vector &vTangentS, const Vector &vTangentT, int t, int s, int tmax, int smax );
struct ProcessLightmapSampleData_t
{
float m_ooQuadraticAttn;
float m_ooRadiusSq;
Vector m_Intensity;
float m_LightDistSqr;
Vector m_vLightOrigin;
ProcessLightmapSampleFunc_t *pProcessLightmapSampleDataFunc;
};
#ifndef DEDICATED
static void ProcessLightmapSample( const ProcessLightmapSampleData_t &data, const Vector &vPos, const Vector &vNormal, const Vector &vTangentS, const Vector &vTangentT, int t, int s, int tmax, int smax )
{
float distSqr = data.m_vLightOrigin.DistToSqr( vPos );
if( distSqr < data.m_LightDistSqr )
{
float scale = (distSqr != 0.0f) ? data.m_ooQuadraticAttn / distSqr : 1.0f;
// Apply a little extra attenuation
scale *= (1.0f - distSqr * data.m_ooRadiusSq);
if (scale > 2.0f)
scale = 2.0f;
int index = t*smax + s;
VectorMA( blocklights[0][index].AsVector3D(),
scale, data.m_Intensity,
blocklights[0][index].AsVector3D() );
}
}
static void ProcessLightmapSampleBumped( const ProcessLightmapSampleData_t &data, const Vector &vPos, const Vector &vNormal, const Vector &vTangentS, const Vector &vTangentT, int t, int s, int tmax, int smax )
{
float distSqr = data.m_vLightOrigin.DistToSqr( vPos );
if( distSqr < data.m_LightDistSqr )
{
float scale = (distSqr != 0.0f) ? data.m_ooQuadraticAttn / distSqr : 1.0f;
// Get the vector from the surface to the light in world space
Vector vLightVecWorld;
VectorSubtract( data.m_vLightOrigin, vPos, vLightVecWorld );
VectorNormalize( vLightVecWorld );
// Transform the vector from the surface to the light into tangent space
Vector vLightVecTangent;
vLightVecTangent.x = DotProduct( vTangentS, vLightVecWorld );
vLightVecTangent.y = DotProduct( vTangentT, vLightVecWorld );
vLightVecTangent.z = DotProduct( vNormal, vLightVecWorld );
// Apply a little extra attenuation
scale *= (1.0f - distSqr * data.m_ooRadiusSq);
if (scale > 2.0f)
scale = 2.0f;
int index = t*smax + s;
float directionalAtten;
directionalAtten = fpmax( 0.0f, vLightVecTangent.z );
VectorMA( blocklights[0][index].AsVector3D(), scale * directionalAtten,
data.m_Intensity,
blocklights[0][index].AsVector3D() );
directionalAtten = fpmax( 0.0f, DotProduct( vLightVecTangent, g_localBumpBasis[0] ) );
VectorMA( blocklights[1][index].AsVector3D(), scale * directionalAtten,
data.m_Intensity,
blocklights[1][index].AsVector3D() );
directionalAtten = fpmax( 0.0f, DotProduct( vLightVecTangent, g_localBumpBasis[1] ) );
VectorMA( blocklights[2][index].AsVector3D(), scale * directionalAtten,
data.m_Intensity,
blocklights[2][index].AsVector3D() );
directionalAtten = fpmax( 0.0f, DotProduct( vLightVecTangent, g_localBumpBasis[2] ) );
VectorMA( blocklights[3][index].AsVector3D(), scale * directionalAtten,
data.m_Intensity,
blocklights[3][index].AsVector3D() );
}
}
//-----------------------------------------------------------------------------
// Alpha channel modulation
//-----------------------------------------------------------------------------
static void ProcessLightmapSampleAlpha( const ProcessLightmapSampleData_t &data, const Vector &vPos, const Vector &vNormal, const Vector &vTangentS, const Vector &vTangentT, int t, int s, int tmax, int smax )
{
float distSqr = data.m_vLightOrigin.DistToSqr( vPos );
if( distSqr < data.m_LightDistSqr )
{
float scale = (distSqr != 0.0f) ? data.m_ooQuadraticAttn / distSqr : 1.0f;
// Apply a little extra attenuation
scale *= (1.0f - distSqr * data.m_ooRadiusSq);
if (scale > 1.0f)
scale = 1.0f;
int index = t*smax + s;
blocklights[0][index][3] += scale * data.m_Intensity[0];
}
}
#endif
// This iterates over all the lightmap samples and for each one, calls:
// T::ProcessLightmapSample( Vector const &vPos, int t, int s, int tmax, int smax );
void IterateLightmapSamples( CDispInfo *pDisp, const ProcessLightmapSampleData_t &data )
{
ASSERT_SURF_VALID( pDisp->m_ParentSurfID );
int smax = MSurf_LightmapExtents( pDisp->m_ParentSurfID )[0] + 1;
int tmax = MSurf_LightmapExtents( pDisp->m_ParentSurfID )[1] + 1;
unsigned char *pCurSample = &g_DispLightmapSamplePositions[pDisp->m_iLightmapSamplePositionStart];
for( int t = 0 ; t<tmax ; t++ )
{
for( int s=0 ; s<smax ; s++ )
{
// Figure out what triangle this sample is on.
// NOTE: this usually stores 4 bytes per lightmap sample.
// It's a lot simpler and faster to just store the position but then it's
// 16 bytes instead of 4.
int iTri;
if( *pCurSample == 255 )
{
++pCurSample;
iTri = *pCurSample + 255;
}
else
{
iTri = *pCurSample;
}
++pCurSample;
float a = (float)*(pCurSample++) / 255.0f;
float b = (float)*(pCurSample++) / 255.0f;
float c = (float)*(pCurSample++) / 255.0f;
CTriInfo *pTri = &pDisp->m_pPowerInfo->m_pTriInfos[iTri];
Vector vPos =
pDisp->m_MeshReader.Position( pTri->m_Indices[0] ) * a +
pDisp->m_MeshReader.Position( pTri->m_Indices[1] ) * b +
pDisp->m_MeshReader.Position( pTri->m_Indices[2] ) * c;
Vector vNormal, vTangentS, vTangentT;
if( pDisp->NumLightMaps() > 1 )
{
vNormal =
pDisp->m_MeshReader.Normal( pTri->m_Indices[0] ) * a +
pDisp->m_MeshReader.Normal( pTri->m_Indices[1] ) * b +
pDisp->m_MeshReader.Normal( pTri->m_Indices[2] ) * c;
vTangentS =
pDisp->m_MeshReader.TangentS( pTri->m_Indices[0] ) * a +
pDisp->m_MeshReader.TangentS( pTri->m_Indices[1] ) * b +
pDisp->m_MeshReader.TangentS( pTri->m_Indices[2] ) * c;
vTangentT =
pDisp->m_MeshReader.TangentT( pTri->m_Indices[0] ) * a +
pDisp->m_MeshReader.TangentT( pTri->m_Indices[1] ) * b +
pDisp->m_MeshReader.TangentT( pTri->m_Indices[2] ) * c;
}
(*data.pProcessLightmapSampleDataFunc)( data, vPos, vNormal, vTangentS, vTangentT, t, s, tmax, smax );
}
}
}
void CDispInfo::AddSingleDynamicLight( dlight_t& dl )
{
#ifndef SWDS
ProcessLightmapSampleData_t data;
data.m_LightDistSqr = dl.GetRadiusSquared();
float lightStyleValue = LightStyleValue( dl.style );
data.m_Intensity[0] = TexLightToLinear( dl.color.r, dl.color.exponent ) * lightStyleValue;
data.m_Intensity[1] = TexLightToLinear( dl.color.g, dl.color.exponent ) * lightStyleValue;
data.m_Intensity[2] = TexLightToLinear( dl.color.b, dl.color.exponent ) * lightStyleValue;
float minlight = fpmax( g_flMinLightingValue, dl.minlight );
float ooQuadraticAttn = data.m_LightDistSqr * minlight; // / maxIntensity;
data.m_ooQuadraticAttn = ooQuadraticAttn;
data.m_vLightOrigin = dl.origin;
data.m_ooRadiusSq = 1.0f / dl.GetRadiusSquared();;
data.pProcessLightmapSampleDataFunc = &ProcessLightmapSample;
// Touch all the lightmap samples.
IterateLightmapSamples( this, data );
#endif
}
void CDispInfo::AddSingleDynamicLightBumped( dlight_t& dl )
{
#ifndef SWDS
ProcessLightmapSampleData_t data;
data.m_LightDistSqr = dl.GetRadiusSquared();
float lightStyleValue = LightStyleValue( dl.style );
data.m_Intensity[0] = TexLightToLinear( dl.color.r, dl.color.exponent ) * lightStyleValue;
data.m_Intensity[1] = TexLightToLinear( dl.color.g, dl.color.exponent ) * lightStyleValue;
data.m_Intensity[2] = TexLightToLinear( dl.color.b, dl.color.exponent ) * lightStyleValue;
float minlight = fpmax( g_flMinLightingValue, dl.minlight );
float ooQuadraticAttn = data.m_LightDistSqr * minlight; // / maxIntensity;
data.m_ooQuadraticAttn = ooQuadraticAttn;
data.m_vLightOrigin = dl.origin;
data.m_ooRadiusSq = 1.0f / dl.GetRadiusSquared();
data.pProcessLightmapSampleDataFunc = &ProcessLightmapSampleBumped;
// Touch all the lightmap samples.
IterateLightmapSamples( this, data );
#endif
}
void CDispInfo::AddSingleDynamicAlphaLight( dlight_t& dl )
{
#ifndef SWDS
ProcessLightmapSampleData_t data;
data.m_LightDistSqr = dl.GetRadiusSquared();
float lightStyleValue = LightStyleValue( dl.style );
data.m_Intensity[0] = TexLightToLinear( dl.color.r, dl.color.exponent ) * lightStyleValue;
if ( dl.flags & DLIGHT_SUBTRACT_DISPLACEMENT_ALPHA )
data.m_Intensity *= -1.0f;
float minlight = max( g_flMinLightingValue, dl.minlight );
float ooQuadraticAttn = data.m_LightDistSqr * minlight; // / maxIntensity;
data.m_ooQuadraticAttn = ooQuadraticAttn;
data.m_vLightOrigin = dl.origin;
data.m_ooRadiusSq = 1.0f / dl.GetRadiusSquared();
data.pProcessLightmapSampleDataFunc = &ProcessLightmapSampleAlpha;
// Touch all the lightmap samples.
IterateLightmapSamples( this, data );
#endif
}
//-----------------------------------------------------------------------------
// A little cache to help us not project vertices multiple times
//-----------------------------------------------------------------------------
class CDecalNodeSetupCache
{
public:
CDecalNodeSetupCache() : m_CurrentCacheIndex(0) {}
Vector m_ProjectedVert[MAX_DISPVERTS];
int m_CacheIndex[MAX_DISPVERTS];
bool IsCached( int v ) { return m_CacheIndex[v] == m_CurrentCacheIndex; }
void MarkCached( int v ) { m_CacheIndex[v] = m_CurrentCacheIndex; }
void ResetCache() { ++m_CurrentCacheIndex; }
private:
int m_CurrentCacheIndex;
};
//-----------------------------------------------------------------------------
// Check to see which nodes are hit by a decal
//-----------------------------------------------------------------------------
bool CDispInfo::SetupDecalNodeIntersect_R( CVertIndex const &nodeIndex,
int iNodeBitIndex, CDispDecalBase *pDispDecal, ShadowInfo_t const* pInfo,
int iLevel, CDecalNodeSetupCache* pCache )
{
int iNodeIndex = VertIndex( nodeIndex );
if( iLevel+1 < m_Power )
{
// Recurse into child nodes.
bool anyChildIntersected = false;
int iChildNodeBit = iNodeBitIndex + 1;
for( int iChild=0; iChild < 4; iChild++ )
{
CVertIndex const &childNode = m_pPowerInfo->m_pChildVerts[iNodeIndex].m_Verts[iChild];
// If any of our children intersect, then we do too...
if (SetupDecalNodeIntersect_R( childNode, iChildNodeBit, pDispDecal, pInfo, iLevel + 1, pCache ) )
anyChildIntersected = true;
iChildNodeBit += m_pPowerInfo->m_NodeIndexIncrements[iLevel];
}
if (anyChildIntersected)
{
pDispDecal->m_NodeIntersect.Set( iNodeBitIndex );
return true;
}
// None of our children intersect this decal, so neither does the node
return false;
}
// Expand our box by the node and by its side verts.
Vector vMin, vMax;
if (!pCache->IsCached(iNodeIndex))
{
DecalProjectVert( m_MeshReader.Position( iNodeIndex ), pDispDecal, pInfo, pCache->m_ProjectedVert[iNodeIndex] );
pCache->MarkCached(iNodeIndex);
}
vMin = pCache->m_ProjectedVert[iNodeIndex];
vMax = pCache->m_ProjectedVert[iNodeIndex];
// Now test each neighbor + child vert to see if it should exist.
for( int i=0; i < 4; i++ )
{
CVertIndex const &sideVert = m_pPowerInfo->m_pSideVerts[iNodeIndex].m_Verts[i];
CVertIndex const &cornerVert = m_pPowerInfo->m_pSideVertCorners[iNodeIndex].m_Verts[i];
int iSideIndex = VertIndex(sideVert);
if (!pCache->IsCached(iSideIndex))
{
DecalProjectVert( m_MeshReader.Position( iSideIndex ), pDispDecal, pInfo, pCache->m_ProjectedVert[iSideIndex] );
pCache->MarkCached(iSideIndex);
}
VectorMin( pCache->m_ProjectedVert[iSideIndex], vMin, vMin );
VectorMax( pCache->m_ProjectedVert[iSideIndex], vMax, vMax );
int iCornerIndex = VertIndex(cornerVert);
if (!pCache->IsCached(iCornerIndex))
{
DecalProjectVert( m_MeshReader.Position( iCornerIndex ), pDispDecal, pInfo, pCache->m_ProjectedVert[iCornerIndex] );
pCache->MarkCached(iCornerIndex);
}
VectorMin( pCache->m_ProjectedVert[iCornerIndex], vMin, vMin );
VectorMax( pCache->m_ProjectedVert[iCornerIndex], vMax, vMax );
}
// Now just see if our bbox intersects the [0,0] - [1,1] bbox, which is where this
// decal sits.
if( vMin.x <= 1 && vMax.x >= 0 && vMin.y <= 1 && vMax.y >= 0 )
{
// Z cull for shadows...
if( pInfo )
{
if ((vMax.z < 0) || (vMin.z > pInfo->m_MaxDist))
return false;
}
// Ok, this node is needed and its children may be needed as well.
pDispDecal->m_NodeIntersect.Set( iNodeBitIndex );
return true;
}
return false;
}
void CDispInfo::SetupDecalNodeIntersect( CVertIndex const &nodeIndex, int iNodeBitIndex,
CDispDecalBase *pDispDecal, ShadowInfo_t const* pInfo )
{
pDispDecal->m_NodeIntersect.ClearAll();
// Generate a vertex cache, so we're not continually reprojecting vertices...
static CDecalNodeSetupCache cache;
cache.ResetCache();
bool anyIntersection = SetupDecalNodeIntersect_R(
nodeIndex, iNodeBitIndex, pDispDecal, pInfo, 0, &cache );
pDispDecal->m_Flags |= CDispDecalBase::NODE_BITFIELD_COMPUTED;
if (anyIntersection)
pDispDecal->m_Flags &= ~CDispDecalBase::NO_INTERSECTION;
else
pDispDecal->m_Flags |= CDispDecalBase::NO_INTERSECTION;
}
Vector CDispInfo::GetFlatVert( int iVertex )
{
int sideLength = m_pPowerInfo->GetSideLength();
int x = iVertex % sideLength;
int y = iVertex / sideLength;
float ooInt = 1.0f / ( float )( sideLength - 1 );
// Lerp between the left and right edges to get a line along 'x'.
Vector endPts[2];
VectorLerp( m_BaseSurfacePositions[0], m_BaseSurfacePositions[1], y*ooInt, endPts[0] );
VectorLerp( m_BaseSurfacePositions[3], m_BaseSurfacePositions[2], y*ooInt, endPts[1] );
// Lerp along the X line.
Vector vOutputPos;
VectorLerp( endPts[0], endPts[1], x*ooInt, vOutputPos );
// This can be used to verify that the position generated here is correct.
// It should be the same as CCoreDispInfo::GetFlatVert.
// Assert( vOutputPos.DistTo( m_Verts[iVertex].m_vFlatPos ) < 0.1f );
// Voila!
return vOutputPos;
}
//-----------------------------------------------------------------------------
// Computes the texture + lightmap coordinate given a displacement uv
//-----------------------------------------------------------------------------
void CDispInfo::ComputeLightmapAndTextureCoordinate( RayDispOutput_t const& output,
Vector2D* luv, Vector2D* tuv )
{
#ifndef SWDS
// lightmap coordinate
if( luv )
{
ComputePointFromBarycentric(
m_MeshReader.TexCoordVector2D( output.ndxVerts[0], DISP_LMCOORDS_STAGE ),
m_MeshReader.TexCoordVector2D( output.ndxVerts[1], DISP_LMCOORDS_STAGE ),
m_MeshReader.TexCoordVector2D( output.ndxVerts[2], DISP_LMCOORDS_STAGE ),
output.u, output.v, *luv );
// luv is in the space of the accumulated lightmap page; we need to convert
// it to be in the space of the surface
int lightmapPageWidth, lightmapPageHeight;
materials->GetLightmapPageSize(
SortInfoToLightmapPage(MSurf_MaterialSortID( m_ParentSurfID ) ),
&lightmapPageWidth, &lightmapPageHeight );
luv->x *= lightmapPageWidth;
luv->y *= lightmapPageHeight;
luv->x -= 0.5f + MSurf_OffsetIntoLightmapPage( m_ParentSurfID )[0];
luv->y -= 0.5f + MSurf_OffsetIntoLightmapPage( m_ParentSurfID )[1];
}
// texture coordinate
if( tuv )
{
// Compute base face (u,v) at each of the three vertices
int size = (1 << m_Power) + 1;
Vector2D baseUV[3];
for (int i = 0; i < 3; ++i )
{
baseUV[i].y = (int)(output.ndxVerts[i] / size);
baseUV[i].x = output.ndxVerts[i] - size * baseUV[i].y;
baseUV[i] /= size - 1;
}
Vector2D basefaceUV;
ComputePointFromBarycentric( baseUV[0], baseUV[1], baseUV[2],
output.u, output.v, basefaceUV );
// Convert the base face uv to a texture uv based on the base face texture coords
TexCoordInQuadFromBarycentric( m_BaseSurfaceTexCoords[0],
m_BaseSurfaceTexCoords[3], m_BaseSurfaceTexCoords[2], m_BaseSurfaceTexCoords[1],
basefaceUV, *tuv );
}
#endif
}
//-----------------------------------------------------------------------------
// Cast a ray against this surface
//-----------------------------------------------------------------------------
bool CDispInfo::TestRay( Ray_t const& ray, float start, float end, float& dist,
Vector2D* luv, Vector2D* tuv )
{
// Get the index associated with this disp info....
int idx = DispInfo_ComputeIndex( host_state.worldbrush->hDispInfos, this );
CDispCollTree* pTree = CollisionBSPData_GetCollisionTree( idx );
if (!pTree)
return false;
CBaseTrace tr;
tr.fraction = 1.0f;
// Only test the portion of the ray between start and end
Vector startpt, endpt,endpt2;
VectorMA( ray.m_Start, start, ray.m_Delta, startpt );
VectorMA( ray.m_Start, end, ray.m_Delta, endpt );
Ray_t shortenedRay;
shortenedRay.Init( startpt, endpt );
RayDispOutput_t output;
output.dist = 1.0f;
if (pTree->AABBTree_Ray( shortenedRay, output ))
{
Assert( (output.u <= 1.0f) && (output.v <= 1.0f ));
Assert( (output.u >= 0.0f) && (output.v >= 0.0f ));
// Compute the actual distance along the ray
dist = start * (1.0f - output.dist) + end * output.dist;
// Compute lightmap + texture coordinates
ComputeLightmapAndTextureCoordinate( output, luv, tuv );
return true;
}
return false;
}
const CPowerInfo* CDispInfo::GetPowerInfo() const
{
return m_pPowerInfo;
}
CDispNeighbor* CDispInfo::GetEdgeNeighbor( int index )
{
Assert( index >= 0 && index < ARRAYSIZE( m_EdgeNeighbors ) );
return &m_EdgeNeighbors[index];
}
CDispCornerNeighbors* CDispInfo::GetCornerNeighbors( int index )
{
Assert( index >= 0 && index < ARRAYSIZE( m_CornerNeighbors ) );
return &m_CornerNeighbors[index];
}
CDispUtilsHelper* CDispInfo::GetDispUtilsByIndex( int index )
{
return GetDispByIndex( index );
}
Reference in New Issue View Git Blame Copy Permalink