RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
FC1/CryAnimation/CryModelSubmesh.cpp
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

1674 lines
53 KiB
C++
Raw Permalink Blame History

#include "stdafx.h"
#include "cvars.h"
#include <MakMatInfoFromMAT_ENTITY.h>
#include <MeshIdx.h>
#include <CryCompiledFile.h>
#include <IEdgeConnectivityBuilder.h>
#include "CryCharReShadowVolume.h"
#include "CryModelState.h"
#include "VertexBufferArrayDrivers.h"
#include "CryModel.h"
#include "CryCharBody.h"
#include "CryCharDecalManager.h"
#include "CryModelSubmesh.h"
#include <VertexBufferSource.h>
#include "IncContHeap.h"
#include "CryModEffMorph.h"
#include "CrySkinMorph.h"
#include "CrySkinFull.h"
#include "CryCharInstance.h"
#include "DebugUtils.h"
#include "Cry_Camera.h"
// initializes and binds the submesh to the given model
// there's no way to change the model at runtime
CryModelSubmesh::CryModelSubmesh (CryModelState* pParent, CryModel* pMesh):
#ifdef DEBUG_STD_CONTAINERS
m_arrMorphEffectors ("CryModelState.MorphTargets"),
#endif
m_pParent(pParent),
m_pDecalManager (NULL),
m_nLastSkinBBoxUpdateFrameId(0),
m_nLastTangentsUpdatedFrameId(0),
m_nLastTangentsUpdatedLOD(-1),
m_pMesh(pMesh),
m_nFlags (FLAG_DEFAULT_FLAGS)
{
// the submeshes that are not the default model submeshes lock their corresponding
// CryModels. The default model can't lock its parent CryModel, because it will
// be circular dependency. Owner ship is as follows: States->CryModel->Default State
// It's for sure that the default model state is being created if there's none in the mesh yet.
if (pParent != pMesh->m_pDefaultModelState && NULL != pMesh->m_pDefaultModelState)
pMesh->m_pBody->AddRef();
for (unsigned i = 0; i < SIZEOF_ARRAY(m_pLeafBuffers); ++i)
m_pLeafBuffers[i] = NULL;
if (pMesh->m_pDefaultModelState != pParent && pMesh->m_pDefaultModelState)
CopyLeafBuffers(pMesh->m_pDefaultModelState->GetCryModelSubmesh(0)->m_pLeafBuffers);
list2<CMatInfo>* pMats = getLeafBufferMaterials();
if (pMats)
{
getShaderTemplates(0).reinit(pMats->Count(), -1);
getShaderTemplates(1).reinit(pMats->Count(), -1);
}
m_nLastUpdatedLodLevel = -1;
for (int i = 0; i < g_nMaxLods; ++i)
{
m_nLastSkinnedFrameID[i] = -1;
m_nLastTangedFrameID[i] = -1;
}
}
// this is the array that's returned from the LeafBuffer
list2<CMatInfo>* CryModelSubmesh::getLeafBufferMaterials()
{
if (m_pLeafBuffers[0])
return m_pLeafBuffers[0]->m_pMats;
else
return NULL;
}
CryModelSubmesh::~CryModelSubmesh()
{
#ifdef UNIQUE_VERT_BUFF_PER_INSTANCE
DeleteLeafBuffers();
#endif
// if the vertex buffers are not unique per modelstate, then they're deleted by the CryModel destructor
if (m_pDecalManager)
{
delete m_pDecalManager;
m_pDecalManager = NULL;
}
// the submeshes that are not the default model submeshes lock their corresponding
// CryModels. The default model can't lock its parent CryModel, because it will
// be circular dependency. Owner ship is as follows: States->CryModel->Default State
if (m_pParent != m_pMesh->m_pDefaultModelState)
m_pMesh->m_pBody->Release();
}
void CryModelSubmesh::CopyLeafBuffers (CLeafBuffer** pLeafBuffers)
{
// copy leaf buffers
for(unsigned nLod=0; nLod < m_pMesh->numLODs(); nLod++)
{
assert(pLeafBuffers[nLod]);
#ifdef UNIQUE_VERT_BUFF_PER_INSTANCE
CLeafBuffer* pSrcLeafBuffer = pLeafBuffers[nLod];
CLeafBuffer* pNewLeafBuffer = g_GetIRenderer()->CreateLeafBuffer(eBT_Dynamic);//new CLeafBuffer;
pSrcLeafBuffer->CopyTo(pNewLeafBuffer, false);
m_pLeafBuffers[nLod] = pNewLeafBuffer;
#else
m_pLeafBuffers[nLod] = pLeafBuffers[nLod];
#endif
}
}
// returns the model of the submesh, or NULL in case of failure
ICryCharModel* CryModelSubmesh::GetModel ()
{
return m_pMesh->m_pBody;
}
// Disposes the leaf buffers allocated for
void CryModelSubmesh::DeleteLeafBuffers()
{
for(unsigned i=0; i<m_pMesh->numLODs(); i++)
{
if(!m_pLeafBuffers[i])
return;
if(list2<CMatInfo>* &pMats = m_pLeafBuffers[i]->m_pMats)
{
for (int m=0; m<pMats->Count(); m++)
{
CMatInfo *tmp = pMats->Get(m);
SAFE_RELEASE(tmp->pRE);
SShaderItem Sh = tmp->GetShaderItem();
SAFE_RELEASE(Sh.m_pShader);
SAFE_RELEASE(Sh.m_pShaderResources);
}
// during GenerateRenderArrays, we allocate this
if (m_pParent == m_pMesh->m_pDefaultModelState && m_pMesh->m_bDeleteLBMats)
{
assert (m_pParent->GetCryModelSubmesh(0) == this);
delete pMats;
pMats = NULL;
}
}
g_GetIRenderer()->DeleteLeafBuffer(m_pLeafBuffers[i]);
}
}
//////////////////////////////////////////////////////////////////////
// Generation of the leaf buffers for the default model state.
// Done only once - when the default model state is initialized.
// szFileName is the full path to the file
void CryModelSubmesh::GenerateRenderArrays(const char * szFileName)
{
AUTO_PROFILE_SECTION(g_dTimeGenRenderArrays);
for(unsigned nLod = 0; nLod < m_pMesh->numLODs(); nLod++)
{
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLod);
if(!pGeomInfo->numVertices())
break;
// LeafBuffer generation:
// Allocate (CreateLeafBuffer) the leaf buffer from the renderer;
// Initialize (CreateBuffer) it from IndexedMesh generated out of GeomInfo
// Initialize the material list for the leaf buffer, and copy some material properties from
// the CryModel
// Sort the faces in the GeomInfo to synchronize their indices with those in the leaf buffer
{
CLeafBuffer * pVertBuffer =
m_pLeafBuffers[nLod] =
g_GetIRenderer()->CreateLeafBuffer(eBT_Dynamic, "CryModelArray");
CIndexedMesh * pIndexedMesh = pGeomInfo->new3DEngineIndexedMesh();
pGeomInfo->removeUVs(); // we won't need them any more
std::vector<bool> arrMtlUsage;
arrMtlUsage.resize (m_pMesh->numMaterials(), false);
// [Sergiy] HACK Sort faces by material to synchronize with the actual leaf buffer
// mark the used materials
pGeomInfo->sortFacesByMaterial(arrMtlUsage);
{
AUTO_PROFILE_SECTION(g_dTimeShaderLoad);
CMatInfo defaultMaterial;
//calculate the index of max actually used material
unsigned nMaterial, numUsedMtls = 0;
for (nMaterial = 0; nMaterial < arrMtlUsage.size(); ++nMaterial)
if (arrMtlUsage[nMaterial])
numUsedMtls = nMaterial + 1;
//g_GetLog()->LogPlus("\005%d of %d mtls used", numUsedMtls, arrMtlUsage.size());
// make material table with clean elements
list2<CMatInfo>& arrMats = *(pVertBuffer->m_pMats = new list2<CMatInfo>);
arrMats.resize(numUsedMtls);
for (nMaterial = 0; nMaterial < numUsedMtls; ++nMaterial)
{
CMatInfo& rMaterial = arrMats[nMaterial];
// this is the hack that's required because list2 doesn't construct the elements: to copy the vtable
*(unsigned int*)&rMaterial = *(unsigned int*)&defaultMaterial;
if (arrMtlUsage[nMaterial])
{
rMaterial.m_Id = nMaterial;
CIndexedMesh__LoadMaterial (NULL, CryStringUtils::GetParentDirectory(string(szFileName)).c_str(), rMaterial, g_GetIRenderer(), &m_pMesh->getMaterial(nMaterial));
if (rMaterial.pRE)
rMaterial.pRE->m_Flags |= FCEF_DYNAMIC;
}
else
rMaterial = defaultMaterial;
}
}
pVertBuffer->CreateBuffer (pIndexedMesh, g_GetCVars()->ca_StripifyGeometry()?true:false,
false); // do not remove any geometry because it will destroy mapping of animation data to leaf buffer data
delete pIndexedMesh;
}
//assert (m_pLeafBuffers[nLod]->m_pMats->size() == m_pMesh->numMaterials());
{
// this is for the new skinning pass
pGeomInfo->PrepareExtToIntMap (m_pLeafBuffers[nLod]->m_SecVertCount);
pGeomInfo->initExtUVs (CVertexBufferUVArrayDriver (m_pLeafBuffers[nLod]));
ushort * pInds = m_pLeafBuffers[nLod]->m_pIndicesPreStrip->Get(0);
uint * pVertReMaping = m_pLeafBuffers[nLod]->m_arrVertStripMap;
for (unsigned i=0; i<pGeomInfo->numFaces(); i++)
{
if( pInds[0] >= m_pLeafBuffers[nLod]->m_SecVertCount ||
pInds[1] >= m_pLeafBuffers[nLod]->m_SecVertCount ||
pInds[2] >= m_pLeafBuffers[nLod]->m_SecVertCount )
{
g_GetConsole()->Exit("CryModelState::GenerateRenderArrays: indices out of range: %s", szFileName);
break;
}
GeomFace face = pGeomInfo->getFace(i);
if(pVertReMaping)
{
for (int v = 0; v < 3; ++v)
{
assert(pVertReMaping[pInds[v]]<pGeomInfo->numExtToIntMapEntries());//flip
pGeomInfo->getExtToIntMapEntry(pVertReMaping[pInds[v]]) = face[v];//flip
}
}
else
{
for (int v = 0; v < 3; ++v)
pGeomInfo->getExtToIntMapEntry(pInds[v]) = face[v];//flip
}
pInds += 3;
}
pGeomInfo->CreateIntToExtMap();
}
}
}
// Creates Leaf buffers for all LODs
// szTextureDir is the texture directory used to create the shaders
void CryModelSubmesh::GenerateRenderArraysCCG(const char * szTextureDir)
{
AUTO_PROFILE_SECTION(g_dTimeGenRenderArrays);
for(unsigned nLod = 0; nLod < m_pMesh->numLODs(); nLod++)
{
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLod);
///////////
// construct the vertices for the renderer to calculate its stuff
//
CrySkinFull* pSkin = pGeomInfo->getGeomSkin();
g_Temp.reserve (sizeof(Vec3d)*(pGeomInfo->numUsedVertices()+pGeomInfo->numExtToIntMapEntries()));
Vec3d* pVertices = (Vec3d*)g_Temp.data();
pSkin->skin (m_pParent->getBoneGlobalMatrices(), pVertices);
Vec3d* pExtVertices = pVertices + pGeomInfo->numUsedVertices();
const unsigned* pExtToIntMap = pGeomInfo->getExtToIntMapEntries();
for (unsigned i = 0; i < pGeomInfo->numExtToIntMapEntries(); ++i)
pExtVertices[i] = pVertices[pExtToIntMap[i]];
CMatInfo defaultMaterial;
list2<CMatInfo>* pMats = new list2<CMatInfo>;
pMats->resize(m_pMesh->numMaterials());
{
AUTO_PROFILE_SECTION(g_dTimeShaderLoad);
for (unsigned nMaterial = 0; nMaterial < pMats->size(); ++nMaterial)
{
CMatInfo& rMaterial = (*pMats)[nMaterial];
// this is the hack that's required because list2 doesn't construct the elements: to copy the vtable
*(unsigned int*)&rMaterial = *(unsigned int*)&defaultMaterial;
rMaterial.m_Id = nMaterial;
CIndexedMesh__LoadMaterial (NULL, szTextureDir, rMaterial, g_GetIRenderer(), &m_pMesh->getMaterial(nMaterial));
if (rMaterial.pRE)
rMaterial.pRE->m_Flags |= FCEF_DYNAMIC;
}
}
/////////////////////////////////////////////////////////////////////////////////
// Construct the Leaf Buffer
//assert (m_pMesh->m_arrShaders.size() == m_pMesh->m_arrMaterials.size());
m_pLeafBuffers[nLod] = g_GetIRenderer()->CreateLeafBuffer(eBT_Dynamic, "ModelState");
VertexBufferSource vbs;
vbs.numMaterials = (unsigned)m_pMesh->m_arrMaterials.size();
vbs.pMaterials = &m_pMesh->m_arrMaterials[0];
vbs.pShaders = NULL;
vbs.pMats = pMats;
vbs.numPrimGroups = (unsigned)pGeomInfo->m_arrPrimGroups.size();
vbs.pPrimGroups = &pGeomInfo->m_arrPrimGroups[0];
vbs.numIndices = (unsigned)pGeomInfo->m_arrIndices.size();
vbs.pIndices = &pGeomInfo->m_arrIndices[0];
vbs.numVertices = pGeomInfo->numExtToIntMapEntries();
vbs.pUVs = pGeomInfo->getExtUVs();
vbs.pVertices = pExtVertices;
vbs.nREFlags = FCEF_DYNAMIC;
vbs.pAndFlags = NULL;
vbs.pOrFlags = NULL;
m_pLeafBuffers[nLod]->CreateBuffer (&vbs);
}
}
void CryModelSubmesh::AddCurrentRenderData(CCObject *obj, CCObject *obj1, const SRendParams & rParams)
{
//g_GetLog()->LogToFile("\003 %d.rendering %x %s", g_nFrameID, this, m_pMesh->getFilePathCStr());
int nSort = rParams.nSortValue;
// prevent from render list changing
// todo: use define here
if (obj->m_ObjFlags & FOB_NEAREST)
nSort = eS_Nearest | (nSort & EFSLIST_MASK);
int nLod = m_pParent->m_nLodLevel;
obj->m_nLod = nLod;
if (obj1)
{
obj1->m_nLod = nLod;
//obj->m_ObjFlags |= FOB_REFRACTED; // moved from Game01
}
CLeafBuffer* pLeafBuffer = m_pLeafBuffers[nLod];
pLeafBuffer->m_vBoxMin = m_SubBBox.vMin;
pLeafBuffer->m_vBoxMax = m_SubBBox.vMax;
// m_pLeafBuffers[nLod]->SetRECustomData(&(m_arrHeatSourcePos[0].x));
int nTempl1;
CryGeometryInfo* pGeomInfo = m_pMesh->getGeometryInfo(nLod);
if (pGeomInfo->m_arrPrimGroups.empty())
{
// the old version : we don't have mapping between materials in mesh and materials in the Leaf Buffers
for(unsigned i=0; i<pLeafBuffer->m_pMats->size(); i++)
{
SShaderItem si = (*pLeafBuffer->m_pMats)[i].shaderItem;
// Override object material.
if (rParams.pMaterial)
{
rParams.pMaterial->OverrideShaderItem( i,si );
}
CREOcLeaf * pREOcLeaf = (*pLeafBuffer->m_pMats)[i].pRE;
if (si.m_pShader && i<(unsigned)pLeafBuffer->m_pMats->Count() && pREOcLeaf)
{
nTempl1 = -1;
int nTempl = rParams.nShaderTemplate;
if (nTempl == -2)
{
nTempl = getShaderTemplates(0)[i];
nTempl1 = getShaderTemplates(1)[i];
}
else
if (rParams.nShaderTemplate > 0)
{
int nTempl = rParams.nShaderTemplate;
si.m_pShader->AddTemplate(si.m_pShaderResources, nTempl, NULL);
}
if (nTempl > 0)
obj->m_nTemplId = nTempl;
g_GetIRenderer()->EF_AddEf(rParams.nFogVolumeID, pREOcLeaf, si.m_pShader, si.m_pShaderResources, obj, nTempl, m_pParent->m_pShaderStateCull?m_pParent->m_pShaderStateCull: rParams.pStateShader , nSort);
if (nTempl1 > 0)
g_GetIRenderer()->EF_AddEf(rParams.nFogVolumeID, pREOcLeaf, si.m_pShader, si.m_pShaderResources, obj1, nTempl1, m_pParent->m_pShaderStateCull?m_pParent->m_pShaderStateCull:rParams.pStateShader , nSort);
}
}
}
else
{
// the new version : we do have mapping between materials in mesh and materials in the Leaf Buffers
for (unsigned nPrimGroup=0; nPrimGroup<pGeomInfo->m_arrPrimGroups.size(); nPrimGroup++)
{
unsigned nMaterial = pGeomInfo->m_arrPrimGroups[nPrimGroup].nMaterial;
CMatInfo& mi = (*pLeafBuffer->m_pMats)[nMaterial];
CREOcLeaf * pREOcLeaf = mi.pRE;
SShaderItem si = mi.shaderItem;//m_pMesh->getShader(nMaterial);
// Override object material.
if (rParams.pMaterial)
{
// Assume that the root material is the first material, sub materials start from index 1.
if (nPrimGroup == 0)
si = rParams.pMaterial->GetShaderItem();
else if (nPrimGroup-1 < unsigned(rParams.pMaterial->GetSubMtlCount()))
{
si = rParams.pMaterial->GetSubMtl(nPrimGroup-1)->GetShaderItem();
}
}
assert (nPrimGroup<(unsigned)pLeafBuffer->m_pMats->size() && pREOcLeaf);
if (si.m_pShader)
{
nTempl1 = -1;
int nTempl = rParams.nShaderTemplate;
if (nTempl == -2)
{
nTempl = getShaderTemplates(0)[nPrimGroup];
nTempl1 = getShaderTemplates(1)[nPrimGroup];
}
else
if (rParams.nShaderTemplate > 0)
{
int nTempl = rParams.nShaderTemplate;
si.m_pShader->AddTemplate(si.m_pShaderResources, nTempl, NULL);
}
if (nTempl > 0)
obj->m_nTemplId = nTempl;
if (nTempl1 > 0)
obj1->m_nTemplId = nTempl1;
// vlad: set default sorting in case of cryvision when set as custom teplate
if(rParams.nShaderTemplate && si.m_pShader->GetTemplate(nTempl)->GetSort() == eS_HeatVision)
{
g_GetIRenderer()->EF_AddEf(rParams.nFogVolumeID, pREOcLeaf, si.m_pShader, si.m_pShaderResources, obj, nTempl, m_pParent->m_pShaderStateCull?m_pParent->m_pShaderStateCull:rParams.pStateShader);
continue;
}
g_GetIRenderer()->EF_AddEf(rParams.nFogVolumeID, pREOcLeaf, si.m_pShader, si.m_pShaderResources, obj, nTempl, m_pParent->m_pShaderStateCull?m_pParent->m_pShaderStateCull:rParams.pStateShader , nSort);
if (nTempl1 > 0)
g_GetIRenderer()->EF_AddEf(rParams.nFogVolumeID, pREOcLeaf, si.m_pShader, si.m_pShaderResources, obj1, nTempl1, m_pParent->m_pShaderStateCull?m_pParent->m_pShaderStateCull:rParams.pStateShader , nSort); }
}
}
}
// renders the decals - adds the render element to the renderer
void CryModelSubmesh::AddDecalRenderData (CCObject *pObj, const SRendParams & rRendParams)
{
if (m_pDecalManager) // we don't render the character decals in lod!=0
m_pDecalManager->AddRenderData (pObj, rRendParams);
}
// returns true if calling Morph () is really necessary (there are any pending morphs)
bool CryModelSubmesh::NeedMorph ()
{
return !m_arrMorphEffectors.empty();
}
// morphs the LOD 0 into the given destination (already skinned) buffer
void CryModelSubmesh::MorphWithSkin (Vec3d* pDst, Vec3dA16* pDstNormalsA16)
{
for (unsigned nMorphEffector = 0; nMorphEffector < m_arrMorphEffectors.size(); ++nMorphEffector)
{
const CryModEffMorph& rMorphEffector = m_arrMorphEffectors[nMorphEffector];
int nMorphTargetId = rMorphEffector.getMorphTargetId ();
if (nMorphTargetId < 0)
continue;
const CrySkinMorph& rMorphSkin = m_pMesh->getMorphSkin (0, nMorphTargetId);
float fBlending = rMorphEffector.getBlending();
if (pDstNormalsA16 && g_GetCVars()->ca_MorphNormals())
rMorphSkin.skin (m_pParent->getBoneGlobalMatrices(), fBlending, pDst, pDstNormalsA16, 1.0f * g_GetCVars()->ca_MorphNormals());
else
rMorphSkin.skin (m_pParent->getBoneGlobalMatrices(), fBlending, pDst);
}
}
// Software skinning: calculate positions and normals
//////////////////////////////////////////////////////////////////////
void CryModelSubmesh::Deform( int nLodToDeform, unsigned nDeformFlags)
{
DEFINE_PROFILER_FUNCTION();
#ifdef _DEBUG
if (m_pParent->m_bOriginalPose && CryStringUtils::stristr(m_pMesh->getFilePathCStr(),"weapon"))
g_GetLog()->LogWarning ("\001%d. Deforming (lod %d, model %s) without any animations applied!", g_nFrameID, nLodToDeform, m_pMesh->getFilePathCStr());
#endif
if ((unsigned)nLodToDeform>=SIZEOF_ARRAY(m_pLeafBuffers))
{
g_GetLog()->LogError ("\001CryModelState::Deform(lod=%d,%s,%s,%s):invalid lod", nLodToDeform, (nDeformFlags&FLAG_DEFORM_UPDATE_TANGENTS)?"Update Tangents":"", (nDeformFlags&FLAG_DEFORM_UPDATE_NORMALS)?"Update Normals":"", (nDeformFlags&FLAG_DEFORM_FORCE_UPDATE)?"Force Update":"");
return;
}
CLeafBuffer *lb = m_pLeafBuffers[nLodToDeform];
if (!lb)
{
g_GetLog()->LogError ("\001CryModelState::Deform(lod=%d,%s,%s,%s):no lod leaf buffer", nLodToDeform, (nDeformFlags&FLAG_DEFORM_UPDATE_TANGENTS)?"Update Tangents":"", (nDeformFlags&FLAG_DEFORM_UPDATE_NORMALS)?"Update Normals":"", (nDeformFlags&FLAG_DEFORM_FORCE_UPDATE)?"Force Update":"");
return;
}
CVertexBuffer* pRenderVertexBuffer = lb->GetVertexContainer()->m_pVertexBuffer;
if (!pRenderVertexBuffer)
{
g_GetLog()->LogError ("\001CryModelState::Deform(lod=%d,%s,%s,%s):no vertex buffer in leaf buffer %x", nLodToDeform, (nDeformFlags&FLAG_DEFORM_UPDATE_TANGENTS)?"Update Tangents":"", (nDeformFlags&FLAG_DEFORM_UPDATE_NORMALS)?"Update Normals":"", (nDeformFlags&FLAG_DEFORM_FORCE_UPDATE)?"Force Update":"", lb);
return;
}
int nVertexFormat = pRenderVertexBuffer->m_vertexformat;
int nNormalsOffset = g_VertFormatNormalOffsets[nVertexFormat];
if (nNormalsOffset >= 0)
nDeformFlags |= FLAG_DEFORM_UPDATE_NORMALS;
#ifdef _DEBUG
static bool bContinue[3] = {true,true,true};
if (!bContinue[nLodToDeform])
return;
#endif
if(!lb)
return;
// if we write directly into video memory - wait for fences first
{
if (!lb->m_pVertexBuffer)
{
// Strange: we are to copy to the videobuffer, but there's no videobuffer.
assert(0);
return;
}
}
bool bRealizeDecals = false;
// we only currently support decals for LOD 0
if (NeedRealizeDecals())
{
if (nLodToDeform == 0)
bRealizeDecals = true;
else
DiscardDecalRequests();
}
int nFrameId = g_GetIRenderer()->GetFrameID();
// get vertices of selected lod
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLodToDeform);
const CryUV* pExtUVs = pGeomInfo->getExtUVs();
TangData * pExtTangents = pGeomInfo->getExtTangents();
unsigned numExtTangents = pGeomInfo->numExtTangents();
Vec3d vNorm, vTang, vBinorm;
CrySkinRigidBasis* pTangSkin = NULL;
bool bSpawnParticles = !m_pParent->m_ParticleManager.empty() && m_nLastSkinnedFrameID[nLodToDeform] < nFrameId;
// the tangents will be skinned here; if it remains NULL, they won't be skinned at all
SPipTangentsA* pTangentBases = NULL;
// these are the sizes of buffers needed in the temporary buffer, in bytes
unsigned
sizeVertices = pGeomInfo->numUsedVertices() * sizeof(Vec3dA16),
sizeNormals = (nDeformFlags&FLAG_DEFORM_UPDATE_NORMALS)?sizeVertices:0,
sizeTangents = 0;
if ((nDeformFlags&FLAG_DEFORM_UPDATE_TANGENTS) && m_pMesh->numBoneInfos())
{
if (
(nDeformFlags&FLAG_DEFORM_FORCE_UPDATE) || // we calculate tangents if the videobuffer has changed and we're forced to recalculate all buffers
!m_nLastTangentsUpdatedFrameId || // we calculate tangents if they haven't been calculated yet
m_nLastTangentsUpdatedLOD != nLodToDeform ||
(nFrameId >= m_nLastTangentsUpdatedFrameId + g_GetCVars()->ca_TangentBasisCalcPeriod()))
{
// we need to recalculate and update the tangents
pTangSkin = pGeomInfo->getTangSkin ();
// we need to update (possibly without recalculation) the tangent bases
// we won't need the tangent bases and vertices simultaneously
sizeTangents = pTangSkin->size()*sizeof(SPipTangentsA);
}
else
nDeformFlags &= ~FLAG_DEFORM_UPDATE_TANGENTS;
}
// we won't need tangents simultaneously with the vertices/normals
g_Temp.reserve (max(sizeTangents, sizeVertices+sizeNormals));
const unsigned* pExtToIntMap = pGeomInfo->getExtToIntMapEntries();
//----------------------------------------------------------------
//----------------------------------------------------------------
//----------------------------------------------------------------
Vec3dA16* pNormals = NULL;
if ((nDeformFlags&FLAG_DEFORM_UPDATE_NORMALS))
pNormals = SelfNormalSkin (nLodToDeform, (((Vec3dA16*)g_Temp.data())+pGeomInfo->numUsedVertices()));
// most probably we'll skin here; sometimes we don't skin and just change the pointer tothe original geometry data
// so, get the pointer to the skin. SelfSkin can also modify normals according to morph targets
const Vec3d* pVertices = NULL;
if ((nDeformFlags&FLAG_DEFORM_UPDATE_VERTICES) || bRealizeDecals || bSpawnParticles)
pVertices = SelfSkin(nLodToDeform, (Vec3d*)g_Temp.data(), pNormals);
if (bRealizeDecals)
RealizeDecals (pVertices);
if (bSpawnParticles)
{
CryCharParticleManager::SpawnParams params;
params.setVertices (pVertices, pGeomInfo->numUsedVertices());
params.setFaces (pGeomInfo->getFaces(), (unsigned)pGeomInfo->numFaces());
params.pModelMatrix = &m_pParent->m_ModelMatrix44;
params.pNormalsA16 = pNormals;
if (params.numBoneMatrices = m_pMesh->numBoneInfos())
params.pBoneGlobalMatrices = m_pParent->getBoneGlobalMatrices();
//spawn particles now, if they don't need normals, because in this case
// the vertices will be destroyed by the normals
m_pParent->m_ParticleManager.spawn (params);
}
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
Vec3d* pVideobuffer = (Vec3d*)pRenderVertexBuffer->m_VS[VSF_GENERAL].m_VData;
unsigned numVerts = (unsigned)lb->m_SecVertCount;
assert (numVerts == pGeomInfo->numExtToIntMapEntries());
if ((nDeformFlags&FLAG_DEFORM_UPDATE_VERTICES))
{
DEFINE_PROFILER_SECTION("ModelDeformVideoMemCopy1");
//CopyPosUVsToVideomemory (pVertices, pExtUVs, numVerts, pExtToIntMap, pVideobuffer, nVertexFormat);
char* pVertBuf = pGeomInfo->getVertBuf(nVertexFormat);
int nVertexFormatSize = m_VertexSize[nVertexFormat];
//----------------------------------------------------------
{
DEFINE_PROFILER_SECTION("Reconstruct-VertexBuffer-PUV");
u32 max=0;
if (!pNormals || nNormalsOffset < 0)
{
for (unsigned i = 0; i < numVerts; ++i){
u32 index=pExtToIntMap[i];
//_mm_prefetch( (char*)&pVertices[index], _MM_HINT_NTA );
*(Vec3d*)(pVertBuf + i * nVertexFormatSize) = pVertices[index];
if (max<index) max=index;
}
} else {
for (unsigned i = 0; i < numVerts; ++i)
{
*(Vec3d*)(pVertBuf + i * nVertexFormatSize) = pVertices[pExtToIntMap[i]];
*(Vec3d*)(pVertBuf + i * nVertexFormatSize + nNormalsOffset) = pNormals[pExtToIntMap[i]].v;
}
}
}
//----------------------------------------------------------
g_GetIRenderer()->UpdateBuffer (pRenderVertexBuffer, pVertBuf, numVerts, true, 0, VSF_GENERAL);
}
static int CTang=0;
CTang=(CTang+1) & 0x00;
if((nDeformFlags&FLAG_DEFORM_UPDATE_TANGENTS)/* && pTangents*/)
{
if (CTang==0)
{
unsigned numTangents;
SPipTangents* pSrc;
if(pTangSkin && g_GetCVars()->ca_EnableTangentSkinning())
{
// this is the number of bases and the bases themselves, as
// they are to be copied to the videomemory (directly)
pTangentBases = (SPipTangentsA*)g_Temp.data(); // use the same mem for the tangents
assert(m_pMesh->numBoneInfos());
numTangents = pTangSkin->size();
#if defined(_CPU_X86) && !defined(LINUX)
if (g_GetCVars()->ca_SSEEnable() && cpu::hasSSE())
pTangSkin->skinSSE (m_pParent->getBoneGlobalMatrices(), pTangentBases);
else
#endif
pTangSkin->skin (m_pParent->getBoneGlobalMatrices(), pTangentBases);
#if 0 && defined(_DEBUG)
for (unsigned nTang = 0; nTang < numTangents; ++nTang)
{
SPipTangentsA& t = pTangentBases[nTang];
assert (t.m_Binormal.Length2() >0.4);
assert (t.m_Tangent.Length2() >0.4);
assert (t.m_TNormal.Length2() >0.4);
}
#endif
#if sizeofSPipTangentsA == 0x30
packVec3d16 (pTangentBases, pTangSkin->size()*3);
#endif
// we've calculated the tangents that are exactly in the same format as in videomem
// (packed 3-float vectors) so we may copy them directly
pSrc = (SPipTangents*)pTangentBases;
assert (pTangSkin->size() == pGeomInfo->numExtToIntMapEntries());
}
else
{
numTangents = numExtTangents;
pSrc = (SPipTangents*)pExtTangents;
}
// copy it from the calculated array
{
DEFINE_PROFILER_SECTION ("ModelDeformVideoMemCopy2");
g_GetIRenderer()->UpdateBuffer (pRenderVertexBuffer, pSrc, numTangents, true, 0, VSF_TANGENTS);
}
}
//memcpy (pTangents, pSrc, sizeof(SPipTangents) * numTangents );
m_nLastTangentsUpdatedFrameId = nFrameId;
m_nLastTangentsUpdatedLOD = nLodToDeform;
}
}
// returns true if the decals need realization (otherwise RealizeDecals() might not be called)
bool CryModelSubmesh::NeedRealizeDecals ()
{
return m_pDecalManager && m_pDecalManager->NeedRealize();
}
// the modelstate gives itself a chance to process decals (realize)
// in this call. The decal realization means creation of geometry that carries the decal
void CryModelSubmesh::RealizeDecals (const Vec3d* pPositions)
{
if (m_pDecalManager)
m_pDecalManager->Realize (pPositions);
}
// discards all outstanding decal requests - the decals that have not been meshed (realized) yet
// and have no chance to be correctly meshed in the future
void CryModelSubmesh::DiscardDecalRequests()
{
if (m_pDecalManager)
m_pDecalManager->DiscardRequests();
}
// do not calculate normals and do not copy into video buffers
// Returns: number of vertices
const Vec3d* CryModelSubmesh::DeformForShadowVolume( int nLodToDeform )
{
return SelfSkin(nLodToDeform);
}
// skins this model (into the given temporary storage, if needed)
// if no storage is provided, then allocates its own storage (g_Temp.data())
// can return the model pre-skinned data (i.e. the returned value is not guaranteed to
// be the same as the buffer passed
// The normals, if not NULL, are modified according to the vertex movements
const Vec3d* CryModelSubmesh::SelfSkin(int nLOD, Vec3d*pVertices, Vec3dA16* pNormalsA16)
{
// if we have links to bones, use them to skin the model
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLOD);
if (m_pMesh->numBoneInfos())
{
unsigned numVertices = pGeomInfo->numUsedVertices();
#if ( defined(_CPU_X86) || defined (_AMD64_) ) && !defined(LINUX)
if (g_GetCVars()->ca_SSEEnable() && cpu::hasSSE())
{
if (!pVertices)
{
g_Temp.reserve (sizeof(Vec3dA16)*numVertices);
pVertices = (Vec3d*)g_Temp.data();
}
CrySkinFull* pSkin = pGeomInfo->getGeomSkin();
pSkin->skinSSE (m_pParent->getBoneGlobalMatrices(), (Vec3dA16*)pVertices);
packVec3d16 (pVertices, numVertices);
CryAABB caabb;
caabb.vMin=pSkin->g_BBox.vMin.v;
caabb.vMax=pSkin->g_BBox.vMax.v;
m_SubBBox = caabb;
m_nLastSkinBBoxUpdateFrameId = g_nFrameID;
}
else
#endif
{
if (!pVertices)
{
g_Temp.reserve (sizeof(Vec3d)*numVertices);
pVertices = (Vec3d*)g_Temp.data();
}
pGeomInfo->getGeomSkin()->skin (m_pParent->getBoneGlobalMatrices(), pVertices);
}
if (nLOD == 0 && NeedMorph() && !g_GetCVars()->ca_NoMorph())
{
// morph the object into the given vertex array to use subsequently in skinning
MorphWithSkin (pVertices, pNormalsA16);
}
return pVertices;
}
else
{
return pGeomInfo->getVertices();
}
}
// Normal-skins this model (into the given storage)
Vec3dA16* CryModelSubmesh::SelfNormalSkin (int nLOD, Vec3dA16* pNormals)
{
// if we have links to bones, use them to skin the model
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLOD);
if (m_pMesh->numBoneInfos())
{
CrySkinFull* pNormalSkin = pGeomInfo->getNormalSkin();
if (!pNormalSkin->empty())
{
//reserve for the normals in the internal indexation and for the normals in outer indexation
pNormalSkin->skinAsVec3d16 (m_pParent->getBoneGlobalMatrices(), pNormals);
return pNormals;
}
}
return NULL;
}
//////////////////////////////////////////////////////////////////////
//this is called only at the beginning once for each LOD
void CryModelSubmesh::DeformFirst()
{
// get current LOD geometry
int nLod = m_pParent->m_nLodLevel;
CryGeometryInfo * pGeomInfo = m_pMesh->getGeometryInfo(nLod);
unsigned numVertices = pGeomInfo->numVertices();
unsigned i;
// deform positions into pGeomInfo->m_pVertices
for(i = 0; i < numVertices; i++)
{
Vec3d & p = pGeomInfo->getVertex(i);
if (pGeomInfo->numLinks())
{
p.x = p.y = p.z = 0;
const CryVertexBinding& arrLinks = pGeomInfo->getLink(i);
for (CryVertexBinding::const_iterator itLink = arrLinks.begin(); itLink != arrLinks.end(); ++itLink)
{
Matrix44& matBoneGlobal = m_pParent->getBoneMatrixGlobal(itLink->BoneID);
p += matBoneGlobal.TransformPointOLD(itLink->offset) * itLink->Blending;
}
}
}
// calc nomals for default pose for this LOD into pGeomInfo->m_pVertices
pGeomInfo->recalculateNormals();
// at this point in pGeomInfo there are positions and normals for zero frame
if(!m_pLeafBuffers[nLod])
return;
// now put pos and normals into leaf secondary buffer
CLeafBuffer * lb = m_pLeafBuffers[nLod];
const unsigned* pExtToIntMap = pGeomInfo->getExtToIntMapEntries();
int StrPos;
byte *pPos = lb->GetPosPtr(StrPos, 0, true);
int StrNor;
byte *pNor = lb->GetNormalPtr(StrNor, 0, true);
for (i=0; i<(unsigned)lb->m_SecVertCount; i++, pPos+=StrPos, pNor+=StrNor)
{
unsigned sn = pExtToIntMap[i];
assert(sn<pGeomInfo->numVertices());
if (pPos)
{
Vec3d *v = (Vec3d *)pPos;
v->x = pGeomInfo->getVertex(sn).x;
v->y = pGeomInfo->getVertex(sn).y;
v->z = pGeomInfo->getVertex(sn).z;
}
assert ( GetLengthSquared(pGeomInfo->getNormal(sn)) > 0.4);
if (pNor)
{
Vec3d *v = (Vec3d *)pNor;
v->x = pGeomInfo->getNormal(sn).x;
v->y = pGeomInfo->getNormal(sn).y;
v->z = pGeomInfo->getNormal(sn).z;
}
}
// calculate tangent basises
lb->CreateTangBuffer();
if((unsigned)lb->m_SecVertCount > pGeomInfo->numExtTangents())
g_GetConsole()->Exit("Error: CryModelState::DeformFirst: lb->m_SecVertCount > pGeomInfo->m_nAllocatedTangNum (%d)", lb->m_SecVertCount);
// copy tangent basises into pGeom
//pSecBuff = (PipVertex *)lb->m_pSecVertBuffer->m_data;
SPipTangents *pTangBuff = (SPipTangents *)lb->m_pSecVertBuffer->m_VS[VSF_TANGENTS].m_VData;
TangData* pExtTangents = pGeomInfo->getExtTangents();
for (i = 0; i < (unsigned)lb->m_SecVertCount; ++i)
{
assert(i<pGeomInfo->numExtTangents());
// For Debug:
// This is the current vertex:
// (((*pGeomInfo).m_arrVertices).m_pData)[((*pGeomInfo).m_arrExtToIntMap).m_pData[i]]
// This is its normal (may be not from the initial position):
// (((*pGeomInfo).m_arrNormals).m_pData)[((*pGeomInfo).m_arrExtToIntMap).m_pData[i]]
//
/*
assert (pTangBuff[i].m_Binormal.Length2() > 0.4);
assert (pTangBuff[i].m_Tangent.Length2() > 0.4);
assert (pTangBuff[i].m_TNormal.Length2() > 0.4);
*/
pExtTangents[i].binormal = pTangBuff[i].m_Binormal;
pExtTangents[i].tangent = pTangBuff[i].m_Tangent;
pExtTangents[i].tnormal = pTangBuff[i].m_TNormal;
}
//lb->FreeSystemBuffer();
}
//////////////////////////////////////////////////////////////////////
//Calculate shadow volumes,fill buffers and render shadow volumes into the stencil buffer
//TODO: Optimize everything
void CryModelSubmesh::RenderShadowVolumes (const SRendParams *rParams, int nLimitLOD)
{
DEFINE_PROFILER_FUNCTION();
#ifdef _DEBUG
if (g_GetCVars()->ca_DebugRebuildShadowVolumes())
m_pMesh->buildStencilShadowInfos();
#endif
// all of the operations here (except when another PROFILE_FRAME_* is used) are related to deformations, extrusions etc.
// for the shadow volume
int nShadowLOD = max (m_pParent->m_nLodLevel, min2((int)m_pMesh->numLODs()-1, max2(g_GetCVars()->ca_LimitShadowLOD(), nLimitLOD)));
// detect the shadow edges
IStencilShadowConnectivity *pConnectivity = m_pMesh->getStencilShadowConnectivity(nShadowLOD);
DWORD dwVertexCount, dwTriangleCount;
pConnectivity->GetStats(dwVertexCount, dwTriangleCount);
if (dwVertexCount == 0 || dwTriangleCount == 0)
return; // empty shadow volume, don't do anything
IEdgeDetector *iEdgeDetector = Get3DEngine()->GetEdgeDetector();
CryCharReShadowVolume* pReShadowVolume = m_ReShadowManager.newShadow();
if (!pReShadowVolume)
return;
unsigned numVertices = m_pMesh->getGeometryInfo(nShadowLOD)->numUsedVertices();
// compute the deformed character vertices; the character will keep the allocated buffer itself (it won't be allocated)
const Vec3d* pModelVerts = DeformForShadowVolume(nShadowLOD);
// Vec3d vLightPos = rParams->lSource->m_Origin;
Vec3d vLightPos = rParams->pShadowVolumeLightSource->m_Origin;
float fShadowVolumeExtent = g_GetCVars()->ca_ShadowVolumeExtent();
if (fShadowVolumeExtent == 0)
{
if(rParams->fShadowVolumeExtent)
fShadowVolumeExtent = rParams->fShadowVolumeExtent;
else
fShadowVolumeExtent = 20.0f; // the default extent
}
//translate the light pos with respect to the character
Vec3d vLightTrans = vLightPos - rParams->vPos;
//rotate the light pos to compensate the rotation of the shadow volume
//these operations are done to avoid to translate and rotate all shadow volume edges
float fCos = cry_cosf(DEG2RAD(-rParams->vAngles.z));
float fSin = cry_sinf(DEG2RAD(-rParams->vAngles.z));
Vec3d vLSourcePos (
vLightTrans.x*fCos-vLightTrans.y*fSin,
vLightTrans.x*fSin+vLightTrans.y*fCos,
vLightTrans.z);
if(!pConnectivity)return; // nothing more to do
// deformed model vertices
iEdgeDetector->BuildSilhuetteFromPos (pConnectivity, vLSourcePos, pModelVerts);
unsigned numShadowIndices = iEdgeDetector->numShadowVolumeIndices();
unsigned numShadowVertices = iEdgeDetector->numShadowVolumeVertices();
if (numShadowVertices > 1 && numShadowIndices > 1)
{
{
DEFINE_PROFILER_SECTION("ModelShadowVideoAlloc");
pReShadowVolume->prepare (numShadowIndices, numShadowVertices);
}
iEdgeDetector->meshShadowVolume (vLSourcePos, fShadowVolumeExtent, pReShadowVolume->getVertexBuffer(), pReShadowVolume->getIndexBuffer());
{
DEFINE_PROFILER_SECTION("ModelShadowVideoUpdate");
pReShadowVolume->submit (rParams, m_pParent->m_pShaderStateShadowCull);
}
}
else
g_GetLog () -> Log ("WARNING: shadow volume with %d indices and %d vertices generated", numShadowIndices, numShadowVertices);
}
//////////////////////////////////////////////////////////////////////////
// Compute all effectors and remove those whose life time has ended,
// then apply effectors to the bones
void CryModelSubmesh::ProcessSkinning(const Vec3& t, const Matrix44& mtxModel, int nTemplate, int nLod, bool bForceUpdate)
{
if (nLod < 0)
nLod = m_pParent->m_nLodLevel;
m_pParent->m_ModelMatrix44 = mtxModel;
bool bNeedVertices = true;
CLeafBuffer *lb = m_pLeafBuffers[nLod];
SShaderItem si;
for (int i = 0; i < lb->m_pMats->Count(); ++i)
{
si = lb->m_pMats->Get(i)->shaderItem;
if (si.m_pShader)
break;
}
IShader *ef;
assert (si.m_pShader);
ef = si.m_pShader->GetTemplate(nTemplate);
assert (ef);
#ifdef _DEBUG
bool bAllowToCopyIntoVideoBufferDirectly = ((ef->GetFlags3() & EF3_NEEDSYSBUF) == 0);
#endif
bool bShowNormals = g_GetCVars()->r_ShowNormals() != 0;
bool bShowTangents = g_GetCVars()->r_ShowTangents() != 0;
bool bNeedTangents = ef && (ef->GetFlags() & EF_NEEDTANGENTS);
bool bNeedNormals = ef && (ef->GetFlags() & EF_NEEDNORMALS);
int nCurrentFrameID = g_GetIRenderer()->GetFrameID();
#ifdef UNIQUE_VERT_BUFF_PER_INSTANCE
// check if already skinned in this frame
bNeedVertices = bNeedVertices && m_nLastSkinnedFrameID[nLod] != nCurrentFrameID;
bNeedTangents = bNeedTangents && m_nLastTangedFrameID[nLod] != nCurrentFrameID;
//const unsigned nInternalForceUpdatePow = 6;
if(!bNeedVertices && !bForceUpdate && !bNeedTangents &&
(m_pParent->m_uFlags&(CryModelState::nFlagNeedReskinLOD<<nLod)) == 0 &&
m_pLeafBuffers[nLod] &&
m_pLeafBuffers[nLod]->m_pVertexBuffer
// force update every 2^nInternalForceUpdatePow frames: this comparison
// produces false and doesn't let this conditional return
//&&(!g_GetCVars()->ca_SafeReskin() /*|| ((g_GetIRenderer()->GetFrameID() & nInternalForceUpdatePow) != (m_nInstanceNumber & nInternalForceUpdatePow))*/)
)
{
return;
}
#endif
CryAABB bbox = m_pParent->getBBox();
//Vec3 trans=mtxModel.GetTranslationOLD();
//Matrix44 m44 = m_pParent->getBoneMatrixGlobal(0);
// Vec3 trans=m_pParent->m_vOffset;
AABB aabb;
aabb.min=bbox.vMin+t;
aabb.max=bbox.vMax+t;
Vec3 WorldMiddle=(aabb.min+aabb.max)*0.5f;
bool NearCam=0;
f32 dist = GetLength( GetViewCamera().GetPos()-WorldMiddle );
if (dist<2.0f) NearCam=1;
Matrix34 m34=Matrix34::CreateIdentity();
m34 = Matrix34( GetTransposed44(mtxModel) );
m34.SetTranslation(t);
/*{
//debug - this draws the bounding box around the character
static float fColorBBox[4] = {1,1,1,1};
fColorBBox[1]+=0.01f; if (fColorBBox[1]>1.0f) fColorBBox[1]=fColorBBox[1]-1.0f;
debugDrawBBox (m34, CryAABB(bbox.vMin,bbox.vMax), 2, fColorBBox);
// g_pIRenderer->Draw3dBBox(aabb.min,aabb.max);
float fColor[4] = {0,1,0,1};
extern float g_YLine;
// g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"trans: %15.10f %15.10f %15.10f bForceUpdate:%d",t.x,t.y,t.z, bForceUpdate ); g_YLine+=16.0f;
g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"aabbsize: %15.10f %15.10f %15.10f",(aabb.max.x-aabb.min.x),(aabb.max.y-aabb.min.y),(aabb.max.z-aabb.min.z) ); g_YLine+=16.0f;
//g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"trans: %15.10f %15.10f %15.10f bForceUpdate:%d",trans.x,trans.y,trans.z,bForceUpdate ); g_YLine+=16.0f;
//g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"min: %15.10f %15.10f %15.10f",aabb.min.x,aabb.min.y,aabb.min.z ); g_YLine+=16.0f;
//g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"max: %15.10f %15.10f %15.10f",aabb.max.x,aabb.max.y,aabb.max.z ); g_YLine+=16.0f;
//g_YLine+=16.0f;
}*/
//if ( !(GetAsyncKeyState('I') & 0x8000) )
// if ( GetViewCamera().IsAABBVisibleFast(aabb) || bForceUpdate || NearCam )
{
// Deform current LOD
if ( !g_GetCVars()->ca_NoDeform() || bForceUpdate)
{
unsigned nDeformFlags = 0;
if (bNeedTangents||bShowTangents)
nDeformFlags |= FLAG_DEFORM_UPDATE_TANGENTS;
if (bNeedNormals||bShowNormals)
nDeformFlags |= FLAG_DEFORM_UPDATE_NORMALS;
if (bNeedVertices)
nDeformFlags |= FLAG_DEFORM_UPDATE_VERTICES;
if (bForceUpdate)
nDeformFlags |= FLAG_DEFORM_FORCE_UPDATE;
Deform(nLod, nDeformFlags);
m_pParent->m_uFlags &= ~(CryModelState::nFlagNeedReskinLOD<<nLod);
m_nLastUpdatedLodLevel = nLod;
if (bNeedVertices)
m_nLastSkinnedFrameID[nLod] = nCurrentFrameID;
if (bNeedTangents)
m_nLastTangedFrameID[nLod] = nCurrentFrameID;
m_nLastUpdatedLodLevel = nLod;
}
}
}
bool CryModelSubmesh::SetShaderTemplateName (const char *TemplName, int Id, const char *ShaderName,IMatInfo *pCustomMaterial,unsigned nFlags)
{
bool bRes = false;
for (unsigned nLOD = 0; nLOD < m_pMesh->numLODs(); ++nLOD)
{
CLeafBuffer *lb = m_pLeafBuffers[nLOD];
if (lb->m_pMats->Count() > (int)getShaderTemplates(Id).size())
return false;
int nTempl = -1;
if (!ShaderName)
{
int numMaterials = lb->m_pMats->Count();
assert (numMaterials >= 0);
for (unsigned i=0; i < (unsigned)numMaterials; i++)
{
//assert (m_pModelState->m_pMesh == m_pCryCharBody->GetModel());
SShaderItem si = lb->m_pMats->Get(i)->shaderItem;
// Override object material.
if (pCustomMaterial)
{
pCustomMaterial->OverrideShaderItem( i,si );
}
if (si.m_pShader && (*lb->m_pMats)[i].pRE && (*lb->m_pMats)[i].nNumIndices)
{
if (TemplName && TemplName[0])
{
si.m_pShader->AddTemplate(si.m_pShaderResources, nTempl, TemplName, false);
}
getShaderTemplates(Id)[i] = nTempl;
}
}
}
else
for (unsigned i=0; i < getShaderTemplates(Id).size(); ++i)
{
//assert (m_pMesh == m_pModel );
SShaderItem si = lb->m_pMats->Get(i)->shaderItem;
if (!si.m_pShader)
continue;
if (!stricmp(ShaderName, si.m_pShader->GetName()))
{
bRes = true;
if (TemplName && TemplName[0])
si.m_pShader->AddTemplate(si.m_pShaderResources, nTempl, TemplName);
getShaderTemplates(Id)[i] = nTempl;
}
}
}
return bRes;
}
CLeafBuffer* CryModelSubmesh::GetLeafBuffer ()
{
return m_pLeafBuffers[m_pParent->m_nLodLevel];
}
void CryModelSubmesh::SetShaderFloat (const char *Name, float Val, const char *ShaderName)
{
char name[128];
int i;
strcpy(name, Name);
strlwr(name);
int nMat = -1;
if (ShaderName)
{
unsigned nLOD, numLODs = m_pMesh->numLODs();
for (nLOD = 0; nLOD < numLODs; ++nLOD)
{
CLeafBuffer *lb = m_pLeafBuffers[nLOD];
int numMaterials = lb->m_pMats->Count();
assert (numMaterials >= 0);
for (i=0; i<numMaterials; i++)
{
CMatInfo *mi = lb->m_pMats->Get(i);
if (!mi->pRE)
continue;
SShaderItem si = mi->shaderItem;
if (!stricmp(si.m_pShader->GetName(), ShaderName))
{
nMat = i;
break;
}
}
}
}
unsigned j;
for (j = 0; j < m_ShaderParams.size(); ++j)
{
if (!strcmp(name, m_ShaderParams[j].m_Name) && m_ShaderParams[j].m_nMaterial == nMat)
break;
}
if (j == m_ShaderParams.size())
{
SShaderParam pr;
strncpy(pr.m_Name, name, 32);
pr.m_nMaterial = nMat;
m_ShaderParams.push_back(pr);
//g_GetLog()->LogToFile("SetShaderFloat realloc: %d", m_ShaderParams.size());
}
m_ShaderParams[j].m_Type = eType_FLOAT;
m_ShaderParams[j].m_Value.m_Float = Val;
}
void CryModelSubmesh::Render(const struct SRendParams & RendParams, Matrix44& mtxObjMatrix, CryCharInstanceRenderParams& rCharParams, const Vec3& translation)
{
if ( translation.GetLength() == 0.0f )
{
int i=0;
}
/*
Vec3 trans=RendParams.vPos;
float fColor[4] = {0,1,0,1};
extern float g_YLine;
g_pIRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false,"render trans: %15.10f %15.10f %15.10f",trans.x,trans.y,trans.z ); g_YLine+=16.0f;
g_YLine+=16.0f;
*/
if (0 == (m_nFlags&FLAG_VISIBLE))
return;
CCObject * pObj = g_GetIRenderer()->EF_GetObject(true);
//pObj->m_Translation=translation;
pObj->m_SortId = RendParams.fCustomSortOffset;
pObj->m_ObjFlags |= FOB_TRANS_MASK;
// set scissor
// pObj->m_nScissorX1 = RendParams.nScissorX1;
// pObj->m_nScissorY1 = RendParams.nScissorY1;
// pObj->m_nScissorX2 = RendParams.nScissorX2;
// pObj->m_nScissorY2 = RendParams.nScissorY2;
//checl if it should be drawn close to the player
if ((RendParams.dwFObjFlags & FOB_NEAREST) || (rCharParams.m_nFlags & CS_FLAG_DRAW_NEAR) ) { pObj->m_ObjFlags|=FOB_NEAREST; }
else pObj->m_ObjFlags&=~FOB_NEAREST;
pObj->m_Color = rCharParams.m_Color;
pObj->m_Color.a *= RendParams.fAlpha;
//some indoor flags
//if (RendParams.dwFlags & RPF_ZPASS) pObj->m_ObjFlags |= FOB_ZPASS;
//else { if (RendParams.dwFlags & RPF_LIGHTPASS) pObj->m_ObjFlags |= FOB_LIGHTPASS; }
//if (RendParams.dwFObjFlags & RPF_INDOOR) pObj->m_ObjFlags |= FOB_INDOOR;
pObj->m_AmbColor = RendParams.vAmbientColor;
if (g_GetIRenderer()->EF_GetHeatVision()) pObj->m_ObjFlags |= FOB_HOTAMBIENT;
pObj->m_ObjFlags |= RendParams.dwFObjFlags;
pObj->m_Matrix = mtxObjMatrix;
int nTemplID = RendParams.nShaderTemplate;
pObj->m_pShadowCasters = RendParams.pShadowMapCasters;
if (!m_ShaderParams.empty()) pObj->m_ShaderParams = &m_ShaderParams;
if(RendParams.pShadowMapCasters && RendParams.pShadowMapCasters->size()) pObj->m_ObjFlags |= FOB_INSHADOW;
else pObj->m_ObjFlags &= ~FOB_INSHADOW;
pObj->m_pCharInstance = this;
pObj->m_nTemplId = nTemplID;
pObj->m_DynLMMask = RendParams.nDLightMask;
if (g_GetCVars()->ca_ambient_light_range() > 0.05f && !(RendParams.dwFObjFlags & FOB_FOGPASS) && !(RendParams.dwFObjFlags & FOB_LIGHTPASS))
{
float col = (1.0f - RendParams.fDistance/g_GetCVars()->ca_ambient_light_range())*g_GetCVars()->ca_ambient_light_intensity();
if (col >= 0.0f)
{
Vec3 ambientColor(pObj->m_AmbColor.x, pObj->m_AmbColor.y, pObj->m_AmbColor.z);
if (ambientColor.GetLengthSquared()>0.001)
{
rCharParams.m_ambientLight.m_Color = CFColor(ambientColor * col);
// pObj->m_AmbColor -= Vec3d(rCharParams.m_ambientLight.m_Color.r*2.0f, rCharParams.m_ambientLight.m_Color.g*2.0f, rCharParams.m_ambientLight.m_Color.b*2.0f);
rCharParams.m_ambientLight.m_Origin = Vec3d(0, 0, 5000.0f);
rCharParams.m_ambientLight.m_fRadius = 100000000;
rCharParams.m_ambientLight.m_Color = Vec3(col, col, col);
rCharParams.m_ambientLight.m_SpecColor = Vec3(0.0f, 0.0f, 0.0f);
rCharParams.m_ambientLight.m_Flags |= DLF_DIRECTIONAL | DLF_AMBIENT_LIGHT;
g_GetIRenderer()->EF_ADDDlight (&rCharParams.m_ambientLight);
if(rCharParams.m_ambientLight.m_Id>=0)
pObj->m_DynLMMask |= (1<<rCharParams.m_ambientLight.m_Id);
}
}
}
CCObject * pObj1 = NULL;
if (getShaderTemplates(1)[0] > 0)
{
pObj1 = g_GetIRenderer()->EF_GetObject(true);
pObj1->CloneObject(pObj);
pObj1->m_ObjFlags |= FOB_TRANS_MASK;
pObj->m_SortId += 10;
}
// HACK HACK HACK
// If we have less then 10 bones it's not the character
if (m_pMesh->numBoneInfos() > 10)
pObj->m_ObjFlags |= FOB_ENVLIGHTING;
if (g_GetCVars()->ca_EnableLightUpdate() && this == m_pParent->GetSubmesh(0))
{
m_pParent->UpdateHeatSources (pObj, RendParams);
m_pParent->UpdateDynBoundLights (pObj, RendParams);
}
if (!g_GetCVars()->ca_NoDraw())
AddCurrentRenderData (pObj,pObj1,RendParams);
// if (g_GetCVars()->ca_EnableDecals() && !RendParams.bRenderIntoShadowMap)
if (g_GetCVars()->ca_EnableDecals() && !(RendParams.dwFObjFlags & FOB_RENDER_INTO_SHADOWMAP) )
AddDecalRenderData (pObj,RendParams);
//---------------------------------------------------------------
/*
CCObject * pObj = g_GetIRenderer()->EF_GetObject(true);
pObj->m_ObjFlags |= FOB_TRANS_MASK;
// set scissor
pObj->m_nScissorX1 = RendParams.nScissorX1;
pObj->m_nScissorY1 = RendParams.nScissorY1;
pObj->m_nScissorX2 = RendParams.nScissorX2;
pObj->m_nScissorY2 = RendParams.nScissorY2;
//checl if it should be drawn close to the player
if ((RendParams.dwFlags & RPF_DRAWNEAR) || (rCharParams.m_nFlags & CS_FLAG_DRAW_NEAR)) { pObj->m_ObjFlags|=FOB_NEAREST; }
else pObj->m_ObjFlags&=~FOB_NEAREST;
pObj->m_Color = rCharParams.m_Color;
pObj->m_Color.a *= RendParams.fAlpha;
//some indoor flags
if (RendParams.dwFlags & RPF_ZPASS) pObj->m_ObjFlags |= FOB_ZPASS;
else { if (RendParams.dwFlags & RPF_LIGHTPASS) pObj->m_ObjFlags |= FOB_LIGHTPASS; }
if (RendParams.dwFlags & RPF_INDOOR) pObj->m_ObjFlags |= FOB_INDOOR;
pObj->m_AmbColor = RendParams.vAmbientColor;
if (g_GetIRenderer()->EF_GetHeatVision()) pObj->m_ObjFlags |= FOB_HOTAMBIENT;
pObj->m_ObjFlags |= RendParams.dwFObjFlags;
pObj->m_Matrix = mtxObjMatrix;
int nTemplID = RendParams.nShaderTemplate;
pObj->m_pShadowCasters = RendParams.pShadowMapCasters;
if (!m_ShaderParams.empty()) pObj->m_ShaderParams = &m_ShaderParams;
if(RendParams.pShadowMapCasters && RendParams.pShadowMapCasters->size()) pObj->m_ObjFlags |= FOB_INSHADOW;
else pObj->m_ObjFlags &= ~FOB_INSHADOW;
pObj->m_pCharInstance = this;
pObj->m_nTemplId = nTemplID;
pObj->m_DynLMMask = RendParams.nDLightMask;
if (g_GetCVars()->ca_ambient_light_range() > 0.05f && !(RendParams.dwFObjFlags & FOB_FOGPASS) && !(RendParams.dwFObjFlags & FOB_LIGHTPASS))
{
float col = (1.0f - RendParams.fDistance/g_GetCVars()->ca_ambient_light_range())*g_GetCVars()->ca_ambient_light_intensity();
if (col >= 0.0f)
{
Vec3 ambientColor(pObj->m_AmbColor.x, pObj->m_AmbColor.y, pObj->m_AmbColor.z);
if (ambientColor.GetLengthSquared()>0.001)
{
rCharParams.m_ambientLight.m_Color = CFColor(ambientColor * col);
pObj->m_AmbColor -= Vec3d(rCharParams.m_ambientLight.m_Color.r*2.0f, rCharParams.m_ambientLight.m_Color.g*2.0f, rCharParams.m_ambientLight.m_Color.b*2.0f);
rCharParams.m_ambientLight.m_Origin = Vec3d(0, 0, 5000.0f);
rCharParams.m_ambientLight.m_fRadius = 100000000;
rCharParams.m_ambientLight.m_Color = Vec3(col, col, col);
rCharParams.m_ambientLight.m_SpecColor = Vec3(0.0f, 0.0f, 0.0f);
rCharParams.m_ambientLight.m_Flags |= DLF_DIRECTIONAL | DLF_AMBIENT_LIGHT;
g_GetIRenderer()->EF_ADDDlight (&rCharParams.m_ambientLight);
if(rCharParams.m_ambientLight.m_Id>=0) pObj->m_DynLMMask |= (1<<rCharParams.m_ambientLight.m_Id);
}
}
}
CCObject * pObj1 = NULL;
if (getShaderTemplates(1)[0] > 0)
{
pObj1 = g_GetIRenderer()->EF_GetObject(true);
pObj1->CloneObject(pObj);
pObj1->m_ObjFlags |= FOB_TRANS_MASK;
pObj->m_SortId += 10;
}
// HACK HACK HACK
// If we have less then 10 bones it's not the character
if (m_pMesh->numBoneInfos() > 10)
pObj->m_ObjFlags |= FOB_ENVLIGHTING;
if (g_GetCVars()->ca_EnableLightUpdate() && this == m_pParent->GetSubmesh(0))
{
m_pParent->UpdateHeatSources (pObj, RendParams);
m_pParent->UpdateDynBoundLights (pObj, RendParams);
}
if (!g_GetCVars()->ca_NoDraw())
AddCurrentRenderData (pObj,pObj1,RendParams);
if (g_GetCVars()->ca_EnableDecals() && !RendParams.bRenderIntoShadowMap)
AddDecalRenderData (pObj,RendParams);
*/
}
void CryModelSubmesh::UpdateMorphEffectors (float fDeltaTimeSec)
{
unsigned numMorphTargets = (unsigned)m_arrMorphEffectors.size();
unsigned nMorphTarget;
for (nMorphTarget = 0; nMorphTarget < numMorphTargets; ++nMorphTarget)
{
CryModEffMorph& rMorph = m_arrMorphEffectors[nMorphTarget];
rMorph.Tick(fDeltaTimeSec);
}
// clean up the array of morph targets from unused ones
while (!m_arrMorphEffectors.empty() && !m_arrMorphEffectors.back().isActive())
m_arrMorphEffectors.pop_back();
}
void CryModelSubmesh::RunMorph (int nMorphTargetId, const CryCharMorphParams&Params)
{
// find the first free slot in the array of morph target, or create a new one and start morphing there
unsigned nMorphEffector;
for (nMorphEffector = 0; nMorphEffector < m_arrMorphEffectors.size(); ++nMorphEffector)
{
if (!m_arrMorphEffectors[nMorphEffector].isActive())
{
m_arrMorphEffectors[nMorphEffector].StartMorph (nMorphTargetId, Params);
return;
}
}
m_arrMorphEffectors.resize (m_arrMorphEffectors.size()+1);
m_arrMorphEffectors.back().StartMorph (nMorphTargetId, Params);
}
bool CryModelSubmesh::RunMorph (const char* szMorphTarget,const CryCharMorphParams&Params,bool bShowNotFoundWarning)
{
assert(IsValidString(szMorphTarget));
int nMorphTargetId = m_pMesh->findMorphTarget(szMorphTarget);
if (nMorphTargetId < 0)
{
if(g_GetCVars()->ca_AnimWarningLevel() > 0 && bShowNotFoundWarning)
g_GetLog()->LogWarning ("\002CryModelSubmesh::RunMorph: Morph Target \"%s\" Not Found for character \"%s\"", szMorphTarget, m_pMesh->getFilePathCStr());
return false;
}
else
{
RunMorph (nMorphTargetId, Params);
return true;
}
}
bool CryModelSubmesh::StopMorph (int nMorphTargetId)
{
unsigned numStopped = 0;
for (;;)
{
CryModEffMorph* pEffector = getMorphTarget(nMorphTargetId);
if (!pEffector)
break;
pEffector->stop();
++numStopped;
}
return numStopped > 0;
}
bool CryModelSubmesh::SetMorphTime (int nMorphTargetId, float fTime)
{
CryModEffMorph* pEffector = getMorphTarget(nMorphTargetId);
if (pEffector)
{
pEffector->setTime (fTime);
return true;
}
return false;
}
bool CryModelSubmesh::SetMorphSpeed(int nMorphTargetId, float fSpeed)
{
CryModEffMorph* pEffector = getMorphTarget(nMorphTargetId);
if (pEffector)
{
pEffector->setSpeed (fSpeed);
return true;
}
return false;
}
void CryModelSubmesh::StopAllMorphs()
{
m_arrMorphEffectors.clear();
}
void CryModelSubmesh::FreezeAllMorphs()
{
for (MorphEffectorArray::iterator it = m_arrMorphEffectors.begin(); it != m_arrMorphEffectors.end(); ++it)
it->freeze();
}
//returns the morph target effector, or NULL if no such effector found
CryModEffMorph* CryModelSubmesh::getMorphTarget (int nMorphTargetId)
{
unsigned nMorphEffector;
for (nMorphEffector = 0; nMorphEffector < m_arrMorphEffectors.size(); ++nMorphEffector)
if (m_arrMorphEffectors[nMorphEffector].getMorphTargetId() == nMorphTargetId)
return &m_arrMorphEffectors[nMorphEffector];
return NULL;
}
void CryModelSubmesh::AddDecal (CryEngineDecalInfo& Decal)
{
if (!m_pDecalManager)
m_pDecalManager = new CryCharDecalManager (m_pMesh->getGeometryInfo(0));
m_pDecalManager->Add (Decal);
}
// returns true if the given submesh is visible
bool CryModelSubmesh::IsVisible()
{
return (m_nFlags & FLAG_VISIBLE) != 0;
}
// depending on bVisible, either makes the submesh visible or invisible
void CryModelSubmesh::SetVisible (bool bVisible)
{
if (bVisible)
m_nFlags |= FLAG_VISIBLE;
else
m_nFlags &= ~FLAG_VISIBLE;
}
void CryModelSubmesh::ClearDecals()
{
if (m_pDecalManager)
m_pDecalManager->clear();
}
void CryModelSubmesh::PreloadResources(float fDistance, float fTime, int nFlags)
{
for (unsigned i = 0; i < m_pMesh->numLODs(); ++i)
if (m_pLeafBuffers[i])
g_GetIRenderer()->EF_PrecacheResource(m_pLeafBuffers[i], fDistance, fTime, nFlags);
}
Reference in New Issue View Git Blame Copy Permalink