H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
windows
source-engine/studiorender/studiorender.h

932 lines
31 KiB
C
Raw Permalink Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#ifndef CSTUDIORENDER_H
#define CSTUDIORENDER_H
#ifdef _WIN32
#pragma once
#endif
#include "istudiorender.h"
#include "studio.h"
#include "materialsystem/imaterialsystem.h" // for LightDesc_t
// wouldn't have to include these if it weren't for inlines.
#include "materialsystem/imaterial.h"
#include "mathlib/mathlib.h"
#include "utllinkedlist.h"
#include "utlvector.h"
#include "tier1/utllinkedlist.h"
#include "flexrenderdata.h"
#include "mathlib/compressed_vector.h"
#include "r_studiolight.h"
#if defined( _WIN32 ) && !defined( _X360 )
#include <xmmintrin.h>
#endif
#include "tier0/dbg.h"
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class ITexture;
class CPixelWriter;
class CMeshBuilder;
class IMaterialVar;
struct mstudioeyeball_t;
struct eyeballstate_t;
struct lightpos_t;
struct dworldlight_t;
struct DecalClipState_t;
class CStudioRender;
struct StudioRenderContext_t;
struct FlexWeights_t;
namespace OptimizedModel
{
struct FileHeader_t;
struct MeshHeader_t;
struct StripGroupHeader_t;
struct Vertex_t;
struct ModelLODHeader_t;
}
//-----------------------------------------------------------------------------
// FIXME: Remove
//-----------------------------------------------------------------------------
class IStudioDataCache;
extern IStudioDataCache *g_pStudioDataCache;
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
extern CStudioRender g_StudioRender;
//-----------------------------------------------------------------------------
// Defines + structs
//-----------------------------------------------------------------------------
#define MAXLOCALLIGHTS 4
#define MAXLIGHTCOMPUTE 16
enum StudioModelLighting_t
{
LIGHTING_HARDWARE = 0,
LIGHTING_SOFTWARE,
LIGHTING_MOUTH
};
struct lightpos_t
{
Vector delta; // unit vector from vertex to light
float falloff; // light distance falloff
float dot; // light direction * delta;
lightpos_t() {}
private:
// Copy constructors are not allowed
lightpos_t( const lightpos_t& src );
};
struct eyeballstate_t
{
const mstudioeyeball_t *peyeball;
matrix3x4_t mat;
Vector org; // world center of eyeball
Vector forward;
Vector right;
Vector up;
Vector cornea; // world center of cornea
eyeballstate_t() {}
private:
// Copy constructors are not allowed
eyeballstate_t( const eyeballstate_t& src );
};
//-----------------------------------------------------------------------------
// Store decal vertex data here
//-----------------------------------------------------------------------------
#pragma pack(1)
struct DecalVertex_t
{
mstudiomesh_t *GetMesh( studiohdr_t *pHdr )
{
if ((m_Body == 0xFFFF) || (m_Model == 0xFFFF) || (m_Mesh == 0xFFFF))
return NULL;
mstudiobodyparts_t *pBody = pHdr->pBodypart( m_Body );
mstudiomodel_t *pModel = pBody->pModel( m_Model );
return pModel->pMesh( m_Mesh );
}
IMorph *GetMorph( studiohdr_t *pHdr, studiomeshdata_t *pStudioMeshes )
{
if ( (m_Body == 0xFFFF) || (m_Model == 0xFFFF) || (m_Mesh == 0xFFFF) || (m_Group == 0xFFFF) )
return NULL;
mstudiobodyparts_t *pBody = pHdr->pBodypart( m_Body );
mstudiomodel_t *pModel = pBody->pModel( m_Model );
mstudiomesh_t *pMesh = pModel->pMesh( m_Mesh );
studiomeshdata_t* pMeshData = &pStudioMeshes[pMesh->meshid];
studiomeshgroup_t* pGroup = &pMeshData->m_pMeshGroup[m_Group];
return pGroup->m_pMorph;
}
// NOTE: m_Group + m_GroupIndex is necessary only for decals on
// hardware morphs. If COMPACT_DECAL_VERT is for console, we
// could remove group index + group
#ifdef COMPACT_DECAL_VERT
Vector m_Position; // 12
Vector2d32 m_TexCoord; // 16
Vector48 m_Normal; // 22 (packed to m_Body)
byte m_Body; // 24
byte m_Model;
unsigned short m_MeshVertexIndex; // index into the mesh's vertex list
unsigned short m_Mesh;
unsigned short m_GroupIndex; // index into the mesh's vertex list
unsigned short m_Group;
#else
Vector m_Position;
Vector m_Normal;
Vector2D m_TexCoord;
unsigned short m_MeshVertexIndex; // index into the mesh's vertex list
unsigned short m_Body;
unsigned short m_Model;
unsigned short m_Mesh;
unsigned short m_GroupIndex; // index into the group's index list
unsigned short m_Group;
#endif
DecalVertex_t() {}
DecalVertex_t( const DecalVertex_t& src )
{
m_Position = src.m_Position;
m_Normal = src.m_Normal;
m_TexCoord = src.m_TexCoord;
m_MeshVertexIndex = src.m_MeshVertexIndex;
m_Body = src.m_Body;
m_Model = src.m_Model;
m_Mesh = src.m_Mesh;
m_GroupIndex = src.m_GroupIndex;
m_Group = src.m_Group;
}
};
#pragma pack()
//-----------------------------------------------------------------------------
// Temporary meshes
//-----------------------------------------------------------------------------
struct MeshVertexInfo_t
{
mstudiomesh_t *m_pMesh;
int m_nIndex;
};
//-----------------------------------------------------------------------------
// Vertex prefetch count for software skinning
//-----------------------------------------------------------------------------
enum
{
PREFETCH_VERT_COUNT = 4
};
//-----------------------------------------------------------------------------
// Class that actually renders stuff
//-----------------------------------------------------------------------------
class CStudioRender
{
public:
CStudioRender();
~CStudioRender();
// Init, shutdown
InitReturnVal_t Init();
void Shutdown( void );
void EnableScissor( FlashlightState_t *state );
void DisableScissor();
void DrawModel( const DrawModelInfo_t& info, const StudioRenderContext_t& rc, matrix3x4_t *pBoneToWorld, const FlexWeights_t& flex, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
void DrawModelArray( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, int arrayCount, model_array_instance_t *pInstanceData, int instanceStride, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
// Static-prop related draw methods
void DrawModelStaticProp( const DrawModelInfo_t& info, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld, int flags = STUDIORENDER_DRAW_ENTIRE_MODEL );
void DrawStaticPropShadows( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld, int flags );
void DrawStaticPropDecals( const DrawModelInfo_t &drawInfo, const StudioRenderContext_t &rc, const matrix3x4_t &modelToWorld );
void ModelStats( const DrawModelInfo_t& info, const StudioRenderContext_t &rc, matrix3x4_t *pBoneToWorld, const FlexWeights_t &flex, int flags );
// Create, destroy list of decals for a particular model
StudioDecalHandle_t CreateDecalList( studiohwdata_t *pHardwareData );
void DestroyDecalList( StudioDecalHandle_t handle );
// Add decals to a decal list by doing a planar projection along the ray
void AddDecal( StudioDecalHandle_t handle, const StudioRenderContext_t& rc, matrix3x4_t *pBoneToWorld, studiohdr_t *pStudioHdr,
const Ray_t & ray, const Vector& decalUp, IMaterial* pDecalMaterial,
float radius, int body, bool noPokethru, int maxLODToDecal = ADDDECAL_TO_ALL_LODS );
// Shadow state (affects the models as they are rendered)
void AddShadow( IMaterial* pMaterial, void* pProxyData, FlashlightState_t *pFlashlightState, VMatrix *pWorldToTexture, ITexture *pFlashlightDepthTexture );
void ClearAllShadows();
// Release/restore material system objects
void PrecacheGlint();
void UncacheGlint();
// Get the config
void R_MouthComputeLightingValues( float& fIllum, Vector& forward );
void R_MouthLighting( float fIllum, const Vector& normal, const Vector& forward, Vector& light );
// Performs the lighting computation
inline void R_ComputeLightAtPoint3( const Vector &pos, const Vector &norm, Vector &color );
#if defined( _WIN32 ) && !defined( _X360 )
// sse-ized lighting pipeline. lights 4 vertices at once
inline void R_ComputeLightAtPoints3( const FourVectors &pos, const FourVectors &norm, FourVectors &color );
void R_MouthLighting( __m128 fIllum, const FourVectors& normal, const FourVectors& forward, FourVectors& light );
#endif
private:
enum
{
DECAL_DYNAMIC = 0x1,
DECAL_SECONDPASS = 0x2,
};
typedef unsigned short DecalId_t;
struct Decal_t
{
int m_IndexCount;
int m_VertexCount;
float m_FadeStartTime;
float m_FadeDuration;
int m_Flags;
};
struct DecalHistory_t
{
unsigned short m_Material;
unsigned short m_Decal;
DecalId_t m_nId;
unsigned short m_nPad;
};
typedef CUtlLinkedList<DecalVertex_t, unsigned short> DecalVertexList_t;
typedef CUtlVector<unsigned short> DecalIndexList_t;
typedef CUtlLinkedList<Decal_t, unsigned short> DecalList_t;
typedef CUtlLinkedList<DecalHistory_t, unsigned short> DecalHistoryList_t;
struct DecalMaterial_t
{
IMaterial* m_pMaterial;
DecalIndexList_t m_Indices;
DecalVertexList_t m_Vertices;
DecalList_t m_Decals;
};
struct DecalLod_t
{
unsigned short m_FirstMaterial;
DecalHistoryList_t m_DecalHistory;
};
struct DecalModelList_t
{
studiohwdata_t* m_pHardwareData;
DecalLod_t* m_pLod;
int m_nLods; // need to retain because hardware data could be flushed
};
// A temporary structure used to figure out new decal verts
struct DecalBuildVertexInfo_t
{
enum
{
FRONT_FACING = 0x1,
VALID_AREA = 0x2, // If you change this, change ProjectDecalOntoMesh
};
Vector2D m_UV;
unsigned short m_VertexIndex; // index into the DecalVertex_t list
unsigned char m_UniqueID;
unsigned char m_Flags;
private:
// No copy constructors
DecalBuildVertexInfo_t( const DecalBuildVertexInfo_t &src );
};
struct DecalBuildInfo_t
{
IMaterial **m_ppMaterials;
studiohdr_t *m_pStudioHdr;
mstudiomesh_t *m_pMesh;
studiomeshdata_t *m_pMeshData;
DecalMaterial_t *m_pDecalMaterial;
MeshVertexInfo_t *m_pMeshVertices;
const mstudio_meshvertexdata_t *m_pMeshVertexData;
const thinModelVertices_t *m_pMeshThinVertexData;
int m_nGlobalMeshIndex;
DecalBuildVertexInfo_t *m_pVertexBuffer;
float m_Radius;
DecalBuildVertexInfo_t *m_pVertexInfo;
int m_Body;
int m_Model;
int m_Mesh;
int m_Group;
DecalVertexList_t::IndexType_t m_FirstVertex;
unsigned short m_VertexCount;
bool m_UseClipVert;
bool m_NoPokeThru;
};
struct ShadowState_t
{
IMaterial* m_pMaterial;
void* m_pProxyData;
FlashlightState_t * m_pFlashlightState;
VMatrix * m_pWorldToTexture;
ITexture * m_pFlashlightDepthTexture;
};
struct BodyPartInfo_t
{
int m_nSubModelIndex;
mstudiomodel_t *m_pSubModel;
};
struct GlintRenderData_t
{
Vector2D m_vecPosition;
Vector m_vecIntensity;
};
// Global LRU for model decals
struct DecalLRU_t
{
StudioDecalHandle_t m_hDecalHandle;
DecalId_t m_nDecalId;
};
typedef CUtlFixedLinkedList< DecalLRU_t >::IndexType_t DecalLRUListIndex_t;
private:
void SetLightingRenderState();
int R_StudioRenderModel( IMatRenderContext *pRenderContext, int skin, int body, int hitboxset, void /*IClientEntity*/ *pEntity,
IMaterial **ppMaterials, int *pMaterialFlags, int flags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes = NULL );
IMaterial* R_StudioSetupSkinAndLighting( IMatRenderContext *pRenderContext, int index, IMaterial **ppMaterials, int materialFlags,
void /*IClientEntity*/ *pClientEntity, ColorMeshInfo_t *pColorMeshes, StudioModelLighting_t &lighting );
int R_StudioDrawEyeball( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh, studiomeshdata_t* pMeshData,
StudioModelLighting_t lighting, IMaterial *pMaterial, int lod );
int R_StudioDrawPoints( IMatRenderContext *pRenderContext, int skin, void /*IClientEntity*/ *pClientEntity,
IMaterial **ppMaterials, int *pMaterialFlags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes );
int R_StudioDrawMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh, studiomeshdata_t* pMeshData,
StudioModelLighting_t lighting, IMaterial *pMaterial, ColorMeshInfo_t *pColorMeshes, int lod );
int R_StudioRenderFinal( IMatRenderContext *pRenderContext,
int skin, int nBodyPartCount, BodyPartInfo_t *pBodyPartInfo, void /*IClientEntity*/ *pClientEntity,
IMaterial **ppMaterials, int *pMaterialFlags, int boneMask, int lod, ColorMeshInfo_t *pColorMeshes = NULL );
int R_StudioDrawStaticMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh,
studiomeshgroup_t* pGroup, StudioModelLighting_t lighting, float r_blend, IMaterial* pMaterial,
int lod, ColorMeshInfo_t *pColorMeshes );
int R_StudioDrawDynamicMesh( IMatRenderContext *pRenderContext, mstudiomesh_t* pmesh,
studiomeshgroup_t* pGroup, StudioModelLighting_t lighting,
float r_blend, IMaterial* pMaterial, int lod );
int R_StudioDrawGroupHWSkin( IMatRenderContext *pRenderContext, studiomeshgroup_t* pGroup, IMesh* pMesh, ColorMeshInfo_t *pColorMeshInfo = NULL );
int R_StudioDrawGroupSWSkin( studiomeshgroup_t* pGroup, IMesh* pMesh );
void R_StudioDrawHulls( int hitboxset, bool translucent );
void R_StudioDrawBones (void);
void R_StudioVertBuffer( void );
void DrawNormal( const Vector& pos, float scale, const Vector& normal, const Vector& color );
void BoneMatToMaterialMat( matrix3x4_t& boneMat, float materialMat[4][4] );
// Various inner-loop methods
void R_StudioSoftwareProcessMesh( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder,
int numVertices, unsigned short* pGroupToMesh, StudioModelLighting_t lighting, bool doFlex, float r_blend,
bool bNeedsTangentSpace, bool bDX8Vertex, IMaterial *pMaterial );
void R_StudioSoftwareProcessMesh_Normals( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder,
int numVertices, unsigned short* pGroupToMesh, StudioModelLighting_t lighting, bool doFlex, float r_blend,
bool bShowNormals, bool bShowTangentFrame );
template< class T >
void ComputeFlexedVertex_StreamOffset( mstudioflex_t *pflex, T *pvanim, int vertCount, float w1, float w2, float w3, float w4 );
void R_StudioProcessFlexedMesh_StreamOffset( mstudiomesh_t* pmesh, int lod );
template <VertexCompressionType_t T> void FillFlexMeshGroupVB( CMeshBuilder & meshBuilder, studiomeshgroup_t *pGroup );
void R_StudioFlexMeshGroup( studiomeshgroup_t *pGroup );
template<VertexCompressionType_t T> void R_StudioRestoreMesh( mstudiomesh_t* pmesh, studiomeshgroup_t* pMeshData );
void R_StudioProcessFlexedMesh( mstudiomesh_t* pmesh, CMeshBuilder& meshBuilder,
int numVertices, unsigned short* pGroupToMesh );
// Eye rendering using vertex shaders
void SetEyeMaterialVars( IMaterial* pMaterial, mstudioeyeball_t* peyeball,
const Vector& eyeOrigin, const matrix3x4_t& irisTransform, const matrix3x4_t& glintTransform );
void ComputeEyelidStateFACS( mstudiomodel_t *pSubModel );
void R_StudioEyelidFACS( const mstudioeyeball_t *peyeball, const eyeballstate_t *pstate );
void R_StudioEyeballPosition( const mstudioeyeball_t *peyeball, eyeballstate_t *pstate );
// Computes the texture projection matrix for the glint texture
void ComputeGlintTextureProjection( eyeballstate_t const* pState,
const Vector& vright, const Vector& vup, matrix3x4_t& mat );
void R_StudioEyeballGlint( const eyeballstate_t *pstate, IMaterialVar *pGlintTextureVar,
const Vector& vright, const Vector& vup, const Vector& r_origin );
ITexture* RenderGlintTexture( const eyeballstate_t *pstate,
const Vector& vright, const Vector& vup, const Vector& r_origin );
int BuildGlintRenderData( GlintRenderData_t *pData, int nMaxGlints,
const eyeballstate_t *pstate, const Vector& vright, const Vector& vup, const Vector& r_origin );
void R_MouthSetupVertexShader( IMaterial* pMaterial );
// Computes a vertex format to use
VertexFormat_t ComputeSWSkinVertexFormat( IMaterial *pMaterial ) const;
inline bool R_TeethAreVisible( void )
{
return true;
/*
// FIXME: commented out until Gary can change them to just draw black
mstudiomouth_t *pMouth = m_pStudioHdr->pMouth( 0 );
float fIllum = m_FlexWeights[pMouth->flexdesc];
return fIllum > 0.0f;
*/
}
inline StudioModelLighting_t R_StudioComputeLighting( IMaterial *pMaterial, int materialFlags, ColorMeshInfo_t *pColorMeshes );
inline void R_StudioTransform( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 );
inline void R_StudioRotate( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 );
inline void R_StudioRotate( Vector4D& in1, mstudioboneweight_t *pboneweight, Vector4D& out1 );
inline void R_StudioEyeballNormal( mstudioeyeball_t const* peyeball, Vector& org,
Vector& pos, Vector& normal );
void MaterialPlanerProjection( const matrix3x4_t& mat, int count, const Vector *psrcverts, Vector2D *pdesttexcoords );
void AddGlint( CPixelWriter &pixelWriter, float x, float y, const Vector& color );
// Methods associated with lighting
int R_LightGlintPosition( int index, const Vector& org, Vector& delta, Vector& intensity );
void R_LightEffectsWorld( const lightpos_t *light, const Vector& normal, const Vector &src, Vector &dest );
void R_GatherStats( studiomeshgroup_t *pGroup, CMeshBuilder &MeshBuilder, IMesh *pMesh, IMaterial *pMaterial );
public:
// NJS: Messy, but needed for an externally optimized routine to set up the lighting.
void R_InitLightEffectsWorld3();
void (FASTCALL *R_LightEffectsWorld3)( const LightDesc_t *pLightDesc, const lightpos_t *light, const Vector& normal, Vector &dest );
private:
inline float R_WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta );
void InitDebugMaterials( void );
void ShutdownDebugMaterials( void );
int SortMeshes( int* pIndices, IMaterial **ppMaterials, short* pskinref, const Vector& vforward, const Vector& r_origin );
// Computes pose to decal space transforms for decal creation
// returns false if it can't for some reason.
bool ComputePoseToDecal( Ray_t const& ray, const Vector& up );
bool AddDecalToModel( DecalBuildInfo_t& buildInfo );
// Helper methods for decal projection, projects pose space vertex data
bool TransformToDecalSpace( DecalBuildInfo_t& build, const Vector& pos, mstudioboneweight_t *pboneweight, Vector2D& uv );
bool ProjectDecalOntoMesh( DecalBuildInfo_t& build, DecalBuildVertexInfo_t* pVertexInfo, mstudiomesh_t *pMesh );
bool IsFrontFacing( const Vector * norm, const mstudioboneweight_t *pboneweight );
int ComputeClipFlags( DecalBuildVertexInfo_t* pVertexInfo, int i );
void ConvertMeshVertexToDecalVertex( DecalBuildInfo_t& build, int meshIndex, DecalVertex_t& decalVertex, int nGroupIndex = 0xFFFF );
unsigned short AddVertexToDecal( DecalBuildInfo_t& build, int meshIndex, int nGroupIndex = 0xFFFF );
unsigned short AddVertexToDecal( DecalBuildInfo_t& build, DecalVertex_t& vert );
void AddClippedDecalToTriangle( DecalBuildInfo_t& build, DecalClipState_t& clipState );
bool ClipDecal( DecalBuildInfo_t& build, int i1, int i2, int i3, int *pClipFlags );
void AddTriangleToDecal( DecalBuildInfo_t& build, int i1, int i2, int i3, int gi1, int gi2, int gi3 );
void AddDecalToMesh( DecalBuildInfo_t& build );
int GetDecalMaterial( DecalLod_t& decalLod, IMaterial* pDecalMaterial );
int AddDecalToMaterialList( DecalMaterial_t* pMaterial );
// Total number of meshes we have to deal with
int ComputeTotalMeshCount( int iRootLOD, int iMaxLOD, int body ) const;
// Project decals onto all meshes
void ProjectDecalsOntoMeshes( DecalBuildInfo_t& build, int nMeshCount );
// Set up the locations for vertices to use
int ComputeVertexAllocation( int iMaxLOD, int body, studiohwdata_t *pHardwareData, MeshVertexInfo_t *pVertexInfo );
// Removes a decal and associated vertices + indices from the history list
void RetireDecal( DecalModelList_t &list, DecalId_t nDecalID, int iLOD, int iMaxLOD );
// Helper methods related to drawing decals
void DrawSingleBoneDecals( CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial );
bool DrawMultiBoneDecals( CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr );
void DrawSingleBoneFlexedDecals( IMatRenderContext *pRenderContext, CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial );
bool DrawMultiBoneFlexedDecals( IMatRenderContext *pRenderContext, CMeshBuilder& meshBuilder, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr, studioloddata_t *pStudioLOD );
void DrawDecalMaterial( IMatRenderContext *pRenderContext, DecalMaterial_t& decalMaterial, studiohdr_t *pStudioHdr, studioloddata_t *pStudioLOD );
void DrawDecal( const DrawModelInfo_t &drawInfo, int lod, int body );
bool PreDrawDecal( IMatRenderContext *pRenderContext, const DrawModelInfo_t &drawInfo );
// Draw shadows
void DrawShadows( const DrawModelInfo_t& info, int flags, int boneMask );
// Draw flashlight lighting on decals.
void DrawFlashlightDecals( const DrawModelInfo_t& info, int lod );
// Helper methods related to extracting and balancing
float RampFlexWeight( mstudioflex_t &flex, float w );
// Remove decal from LRU
void RemoveDecalListFromLRU( StudioDecalHandle_t h );
// Helper methods related to flexing vertices
void R_StudioFlexVerts( mstudiomesh_t *pmesh, int lod );
// Flex stats
void GetFlexStats( );
// Sets up the hw flex mesh
void ComputeFlexWeights( int nFlexCount, mstudioflex_t *pFlex, MorphWeight_t *pWeights );
// Generate morph accumulator
void GenerateMorphAccumulator( mstudiomodel_t *pSubModel );
// Computes eyeball state
void ComputeEyeballState( mstudiomodel_t *pSubModel );
// Avoid some warnings...
CStudioRender( CStudioRender const& );
public:
// Render context (comes from queue)
StudioRenderContext_t *m_pRC;
private:
// Stores all decals for a particular material and lod
CUtlLinkedList< DecalMaterial_t, unsigned short, true > m_DecalMaterial;
// Stores all decal lists that have been made
CUtlFixedLinkedList< DecalModelList_t > m_DecalList;
CThreadFastMutex m_DecalMutex;
// Stores all shadows to be cast on the current object
CUtlVector<ShadowState_t> m_ShadowState;
matrix3x4_t m_StaticPropRootToWorld;
matrix3x4_t *m_pBoneToWorld; // bone transformation matrix( comes from queue )
matrix3x4_t *m_PoseToWorld; // bone transformation matrix
matrix3x4_t *m_PoseToDecal; // bone transformation matrix
// Flex state, comes from queue
float *m_pFlexWeights;
float *m_pFlexDelayedWeights;
studiohdr_t *m_pStudioHdr;
mstudiomodel_t *m_pSubModel;
studiomeshdata_t *m_pStudioMeshes;
eyeballstate_t m_pEyeballState[16]; // MAXSTUDIOEYEBALLS
// debug materials
IMaterial *m_pMaterialMRMWireframe;
IMaterial *m_pMaterialMRMWireframeZBuffer;
IMaterial *m_pMaterialMRMNormals;
IMaterial *m_pMaterialTangentFrame;
IMaterial *m_pMaterialTranslucentModelHulls;
IMaterial *m_pMaterialSolidModelHulls;
IMaterial *m_pMaterialAdditiveVertexColorVertexAlpha;
IMaterial *m_pMaterialModelBones;
IMaterial *m_pMaterialWorldWireframe;
IMaterial *m_pMaterialModelEnvCubemap;
// Depth override material
IMaterial *m_pDepthWrite[2][2];
IMaterial *m_pSSAODepthWrite[2][2];
// GLINT data
ITexture* m_pGlintTexture;
ITexture* m_pGlintLODTexture;
IMaterial *m_pGlintBuildMaterial;
short m_GlintWidth;
short m_GlintHeight;
// Flex data
CCachedRenderData m_VertexCache;
// Cached variables:
bool m_bSkippedMeshes : 1;
bool m_bDrawTranslucentSubModels : 1;
DecalId_t m_nDecalId;
CUtlFixedLinkedList< DecalLRU_t > m_DecalLRU;
friend class CGlintTextureRegenerator;
friend struct mstudiomodel_t;
friend class CStudioRenderContext;
};
//-----------------------------------------------------------------------------
// Converts matrices to a format material system wants
//-----------------------------------------------------------------------------
/*
================
R_StudioTransform
================
*/
inline void CStudioRender::R_StudioTransform( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 )
{
// MEASURECODE( "R_StudioTransform" );
Vector out2;
switch( pboneweight->numbones )
{
case 1:
VectorTransform( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
break;
/*
case 2:
VectorTransform( in1, m_PoseToWorld[pboneweight->bone[0]], out1 );
out1 *= pboneweight->weight[0];
VectorTransform( in1, m_PoseToWorld[pboneweight->bone[1]], out2 );
VectorMA( out1, pboneweight->weight[1], out2, out1 );
break;
case 3:
VectorTransform( in1, m_PoseToWorld[pboneweight->bone[0]], out1 );
out1 *= pboneweight->weight[0];
VectorTransform( in1, m_PoseToWorld[pboneweight->bone[1]], out2 );
VectorMA( out1, pboneweight->weight[1], out2, out1 );
VectorTransform( in1, m_PoseToWorld[pboneweight->bone[2]], out2 );
VectorMA( out1, pboneweight->weight[2], out2, out1 );
break;
*/
default:
VectorFill( out1, 0 );
for (int i = 0; i < pboneweight->numbones; i++)
{
VectorTransform( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
VectorMA( out1, pboneweight->weight[i], out2, out1 );
}
break;
}
}
/*
================
R_StudioRotate
================
*/
inline void CStudioRender::R_StudioRotate( Vector& in1, mstudioboneweight_t *pboneweight, Vector& out1 )
{
// NOTE: This only works to rotate normals if there's no scale in the
// pose to world transforms. If we ever add scale, we'll need to
// multiply by the inverse transpose of the pose to world
if (pboneweight->numbones == 1)
{
VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
}
else
{
Vector out2;
VectorFill( out1, 0 );
for (int i = 0; i < pboneweight->numbones; i++)
{
VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
VectorMA( out1, pboneweight->weight[i], out2, out1 );
}
VectorNormalize( out1 );
}
}
inline void CStudioRender::R_StudioRotate( Vector4D& realIn1, mstudioboneweight_t *pboneweight, Vector4D& realOut1 )
{
// garymcthack - god this sucks.
Vector in1( realIn1[0], realIn1[1], realIn1[2] );
Vector out1;
if (pboneweight->numbones == 1)
{
VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[0]], out1 );
}
else
{
Vector out2;
VectorFill( out1, 0 );
for (int i = 0; i < pboneweight->numbones; i++)
{
VectorRotate( in1, m_PoseToWorld[(unsigned)pboneweight->bone[i]], out2 );
VectorMA( out1, pboneweight->weight[i], out2, out1 );
}
VectorNormalize( out1 );
}
realOut1.Init( out1[0], out1[1], out1[2], realIn1[3] );
}
//-----------------------------------------------------------------------------
// Compute the contribution of a light depending on it's angle
//-----------------------------------------------------------------------------
/*
light_normal (lights normal translated to same space as other normals)
surface_normal
light_direction_normal | (light_pos - vertex_pos) |
*/
template< int nLightType >
class CWorldLightAngleWrapper
{
public:
FORCEINLINE static float WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta )
{
float dot, dot2, ratio;
switch (nLightType)
{
case MATERIAL_LIGHT_POINT:
#if 1
// half-lambert
dot = DotProduct( snormal, delta );
if (dot < 0.f)
return 0.f;
#else
dot = DotProduct( snormal, delta ) * 0.5 + 0.5;
dot = dot * dot;
#endif
return dot;
case MATERIAL_LIGHT_SPOT:
#if 1
// half-lambert
dot = DotProduct( snormal, delta );
if (dot < 0.)
return 0.f;
#else
dot = DotProduct( snormal, delta ) * 0.5 + 0.5;
dot = dot * dot;
#endif
dot2 = -DotProduct (delta, lnormal);
if (dot2 <= wl->m_PhiDot)
return 0.f; // outside light cone
ratio = dot;
if (dot2 >= wl->m_ThetaDot)
return ratio; // inside inner cone
if ((wl->m_Falloff == 1.f) || (wl->m_Falloff == 0.f))
{
ratio *= (dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot);
}
else
{
ratio *= pow((dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot), wl->m_Falloff );
}
return ratio;
case MATERIAL_LIGHT_DIRECTIONAL:
#if 1
// half-lambert
dot2 = -DotProduct( snormal, lnormal );
if (dot2 < 0.f)
return 0.f;
#else
dot2 = -DotProduct( snormal, lnormal ) * 0.5 + 0.5;
dot2 = dot2 * dot2;
#endif
return dot2;
case MATERIAL_LIGHT_DISABLE:
return 0.f;
NO_DEFAULT;
}
}
};
template< int nLightType >
class CWorldLightAngleWrapperConstDirectional
{
public:
FORCEINLINE static float WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta, float directionalamount )
{
float dot, dot2, ratio;
// directional amount is constant
dot = directionalamount;
if (dot < 0.f)
return 0.f;
switch (nLightType)
{
case MATERIAL_LIGHT_POINT:
case MATERIAL_LIGHT_DIRECTIONAL:
return dot;
case MATERIAL_LIGHT_SPOT:
dot2 = -DotProduct (delta, lnormal);
if (dot2 <= wl->m_PhiDot)
return 0.f; // outside light cone
ratio = dot;
if (dot2 >= wl->m_ThetaDot)
return ratio; // inside inner cone
if ((wl->m_Falloff == 1.f) || (wl->m_Falloff == 0.f))
{
ratio *= (dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot);
}
else
{
ratio *= pow((dot2 - wl->m_PhiDot) / (wl->m_ThetaDot - wl->m_PhiDot), wl->m_Falloff );
}
return ratio;
case MATERIAL_LIGHT_DISABLE:
return 0.f;
NO_DEFAULT;
}
}
};
inline float CStudioRender::R_WorldLightAngle( const LightDesc_t *wl, const Vector& lnormal, const Vector& snormal, const Vector& delta )
{
switch (wl->m_Type)
{
case MATERIAL_LIGHT_DISABLE: return CWorldLightAngleWrapper<MATERIAL_LIGHT_DISABLE>::WorldLightAngle( wl, lnormal, snormal, delta );
case MATERIAL_LIGHT_POINT: return CWorldLightAngleWrapper<MATERIAL_LIGHT_POINT>::WorldLightAngle( wl, lnormal, snormal, delta );
case MATERIAL_LIGHT_DIRECTIONAL: return CWorldLightAngleWrapper<MATERIAL_LIGHT_DIRECTIONAL>::WorldLightAngle( wl, lnormal, snormal, delta );
case MATERIAL_LIGHT_SPOT: return CWorldLightAngleWrapper<MATERIAL_LIGHT_SPOT>::WorldLightAngle( wl, lnormal, snormal, delta );
NO_DEFAULT;
}
}
//-----------------------------------------------------------------------------
// Draws eyeballs
//-----------------------------------------------------------------------------
inline void CStudioRender::R_StudioEyeballNormal( mstudioeyeball_t const* peyeball, Vector& org,
Vector& pos, Vector& normal )
{
// inside of a flattened torus
VectorSubtract( pos, org, normal );
float flUpAmount = DotProduct( normal, peyeball->up );
VectorMA( normal, -0.5 * flUpAmount, peyeball->up, normal );
VectorNormalize( normal );
}
//-----------------------------------------------------------------------------
//
// Stateless utility methods
//
//-----------------------------------------------------------------------------
// Computes the submodel for a specified body + bodypart
int R_StudioSetupModel( int nBodyPart, int nBody, mstudiomodel_t **pSubModel, const studiohdr_t *pStudioHdr );
// Computes PoseToWorld from BoneToWorld
void ComputePoseToWorld( matrix3x4_t *pPoseToWorld, studiohdr_t *pStudioHdr, int boneMask, const Vector& vecViewOrigin, const matrix3x4_t *pBoneToWorld );
// Computes the model LOD
inline int ComputeModelLODAndMetric( studiohwdata_t *pHardwareData, float flUnitSphereSize, float *pMetric )
{
// NOTE: This function was split off since CStudioRender needs it also.
float flMetric = pHardwareData->LODMetric( flUnitSphereSize );
if ( pMetric )
{
*pMetric = flMetric;
}
return pHardwareData->GetLODForMetric( flMetric );
}
#endif // CSTUDIORENDER_H
Reference in New Issue Copy Permalink