tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/decalmsh.cpp

1110 lines
44 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : WW3D *
* *
* $Archive:: /Commando/Code/ww3d2/decalmsh.cpp $*
* *
* Original Author:: Greg Hjelstrom *
* *
* $Author:: Jani_p $*
* *
* $Modtime:: 11/24/01 6:17p $*
* *
* $Revision:: 23 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* DecalMeshClass::DecalMeshClass -- Constructor *
* DecalMeshClass::~DecalMeshClass -- Destructor *
* RigidDecalMeshClass::RigidDecalMeshClass -- Constructor *
* RigidDecalMeshClass::~RigidDecalMeshClass -- Destructor *
* RigidDecalMeshClass::Render -- Render the decals *
* RigidDecalMeshClass::Process_Material_Run -- scans the mesh for material runs *
* RigidDecalMeshClass::Create_Decal -- Generate a new decal *
* RigidDecalMeshClass::Delete_Decal -- Delete a decal *
* SkinDecalMeshClass::SkinDecalMeshClass -- Constructor *
* SkinDecalMeshClass::~SkinDecalMeshClass -- Destructor *
* SkinDecalMeshClass::Render -- Render the decals *
* SkinDecalMeshClass::Create_Decal -- Generate a new decal *
* SkinDecalMeshClass::Delete_Decal -- Delete a decal *
* SkinDecalMeshClass::Process_Material_Run -- scans the mesh for material runs *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "decalmsh.h"
#include "decalsys.h"
#include "rinfo.h"
#include "mesh.h"
#include "meshmdl.h"
#include "plane.h"
#include "statistics.h"
#include "dx8vertexbuffer.h"
#include "dx8indexbuffer.h"
#include "simplevec.h"
#include "texture.h"
#include "dx8wrapper.h"
#include "dx8caps.h"
#define DISABLE_CLIPPING 0
/**
** DecalPolyClass - This class is used to clip polygons as they are
** added to a RigidDecalMesh.
**
** Data needed to add a poly to the decal mesh:
** connectivity - generated on the fly after the poly is clipped
** planeeq - constant for entire poly, copy from source after done
** verts - plug into DecalPolyClass, clip, pull back out
** vnorms - plug into DecalPolyClass, clip, copy back out
** texcoords - compute after poly is clipped
** material - contstant for entire poly, get from generator
** shader - constant for entire poly, get from generator
** texture - constant for entire poly, get from generator
*/
class DecalPolyClass
{
public:
void Reset(void);
void Add_Vertex(const Vector3 & point,const Vector3 & normal);
void Clip(const PlaneClass & plane,DecalPolyClass & dest) const;
SimpleDynVecClass<Vector3> Verts;
SimpleDynVecClass<Vector3> VertNorms;
};
void DecalPolyClass::Reset(void)
{
Verts.Delete_All(false);
VertNorms.Delete_All(false);
}
void DecalPolyClass::Add_Vertex(const Vector3 & point,const Vector3 & norm)
{
Verts.Add(point);
VertNorms.Add(norm);
}
void DecalPolyClass::Clip(const PlaneClass & plane,DecalPolyClass & dest) const
{
dest.Reset();
if (Verts.Count() <= 2) return;
// temporary variables used in clipping
int i = 0;
int iprev = Verts.Count() - 1;
bool cur_point_in_front;
bool prev_point_in_front;
float alpha;
Vector3 int_point;
Vector3 int_normal;
// perform clipping
prev_point_in_front = plane.In_Front(Verts[iprev]);
#if DISABLE_CLIPPING
prev_point_in_front = true;
#endif
for (int j=0; j<Verts.Count(); j++) {
cur_point_in_front = plane.In_Front(Verts[i]);
#if DISABLE_CLIPPING
cur_point_in_front = true;
#endif
if (prev_point_in_front) {
if (cur_point_in_front) {
// Previous vertex was in front of plane and this vertex is in
// front of the plane so we emit this vertex.
dest.Add_Vertex(Verts[i],VertNorms[i]);
} else {
// Previous vert was in front, this vert is behind, compute
// the intersection and emit the point.
plane.Compute_Intersection(Verts[iprev],Verts[i],&alpha);
Lerp(Verts[iprev],Verts[i],alpha,&int_point);
Lerp(VertNorms[iprev],VertNorms[i],alpha,&int_normal);
dest.Add_Vertex(int_point,int_normal);
}
} else {
if (cur_point_in_front) {
// segment is going from the back halfspace to the front halfspace
// compute the intersection and emit it, then continue
// the edge into the front halfspace and emit the end point.
plane.Compute_Intersection(Verts[iprev],Verts[i],&alpha);
Lerp(Verts[iprev],Verts[i],alpha,&int_point);
Lerp(VertNorms[iprev],VertNorms[i],alpha,&int_normal);
dest.Add_Vertex(int_point,int_normal);
dest.Add_Vertex(Verts[i],VertNorms[i]);
}
}
prev_point_in_front = cur_point_in_front;
iprev = i;
i = (i+1)%(Verts.Count());
}
}
static DecalPolyClass _DecalPoly0;
static DecalPolyClass _DecalPoly1;
/*
** DecalMeshClass Implementation
*/
/***********************************************************************************************
* DecalMeshClass::DecalMeshClass -- Constructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/26/00 gth : Created. *
*=============================================================================================*/
DecalMeshClass::DecalMeshClass(MeshClass * parent,DecalSystemClass * system) :
Parent(parent),
DecalSystem(system)
{
WWASSERT(Parent != NULL);
WWASSERT(DecalSystem != NULL);
}
/***********************************************************************************************
* DecalMeshClass::~DecalMeshClass -- Destructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/26/00 gth : Created. *
*=============================================================================================*/
DecalMeshClass::~DecalMeshClass(void)
{
}
/*
** RigidDecalMeshClass Implementation
*/
/***********************************************************************************************
* RigidDecalMeshClass::RigidDecalMeshClass -- Constructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
RigidDecalMeshClass::RigidDecalMeshClass(MeshClass * parent, DecalSystemClass * system) :
DecalMeshClass(parent, system)
{
}
/***********************************************************************************************
* RigidDecalMeshClass::~RigidDecalMeshClass -- Destructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
RigidDecalMeshClass::~RigidDecalMeshClass(void)
{
int i;
// Notify the system that this decal mesh is being destroyed.
for (i=0; i<Decals.Count(); i++) {
DecalSystem->Decal_Mesh_Destroyed(Decals[i].DecalID,this);
}
// Release all of our references. The memory in the arrays will automatically be
// released by the SimpleDynVecClass...
for (i=0; i<Polys.Count(); i++) {
REF_PTR_RELEASE(Textures[i]);
}
for (i=0; i<Verts.Count(); i++) {
REF_PTR_RELEASE(VertexMaterials[i]);
}
}
/***********************************************************************************************
* RigidDecalMeshClass::Render -- Render the decals *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/26/00 gth : Created. *
*=============================================================================================*/
void RigidDecalMeshClass::Render(void)
{
if ((Decals.Count() == 0) || (WW3D::Are_Decals_Enabled() == false)) return;
/*
** Install the mesh'es transform. NOTE, this could go wrong if someone changes the
** transform between the time that the mesh is rendered and the time that the decal
** mesh is rendered... It shouldn't happen though.
*/
DX8Wrapper::Set_Transform(D3DTS_WORLD,Parent->Get_Transform());
/*
** Copy the vertices into the dynamic vb
*/
DynamicVBAccessClass dynamic_vb(BUFFER_TYPE_DYNAMIC_DX8,dynamic_fvf_type,Verts.Count());
{
DynamicVBAccessClass::WriteLockClass lock(&dynamic_vb);
VertexFormatXYZNDUV2 * vertex = lock.Get_Formatted_Vertex_Array();
for (int i=0; i<Verts.Count(); i++) {
vertex->x = Verts[i].X;
vertex->y = Verts[i].Y;
vertex->z = Verts[i].Z;
vertex->nx = VertNorms[i].X;
vertex->ny = VertNorms[i].Y;
vertex->nz = VertNorms[i].Z;
vertex->diffuse = 0xFFFFFFFF;
vertex->u1 = TexCoords[i].X;
vertex->v1 = TexCoords[i].Y;
vertex->u2 = 0.0f;
vertex->v2 = 0.0f;
vertex++;
}
}
/*
** Copy the indices into the dynamic ib
*/
DynamicIBAccessClass dynamic_ib(BUFFER_TYPE_DYNAMIC_DX8,Polys.Count() * 3);
{
DynamicIBAccessClass::WriteLockClass lock(&dynamic_ib);
unsigned short * indices = lock.Get_Index_Array();
for (int i=0; i < Polys.Count(); i++)
{
indices[i*3 + 0] = (unsigned short)Polys[i].I;
indices[i*3 + 1] = (unsigned short)Polys[i].J;
indices[i*3 + 2] = (unsigned short)Polys[i].K;
}
}
/*
** Render in runs of constant material settings
*/
int cur_poly_index = 0;
int next_poly_index = 0;
while (next_poly_index < Polys.Count()) {
next_poly_index = Process_Material_Run(cur_poly_index);
DX8Wrapper::Set_Index_Buffer(dynamic_ib,0);
DX8Wrapper::Set_Vertex_Buffer(dynamic_vb);
DX8Wrapper::Draw_Triangles( 3*cur_poly_index,
(next_poly_index - cur_poly_index), // poly count
Polys[cur_poly_index].I,
1 + Polys[next_poly_index-1].K - Polys[cur_poly_index].I);
cur_poly_index = next_poly_index;
}
}
/***********************************************************************************************
* RigidDecalMeshClass::Process_Material_Run -- scans the mesh for material runs *
* *
* This function will install the materials for poly[start_index] and scan forward for *
* the next material change. It will return the start index for the next material change *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 2/22/2001 gth : Created. *
*=============================================================================================*/
int RigidDecalMeshClass::Process_Material_Run(int start_index)
{
DX8Wrapper::Set_Texture(0,Textures[start_index]);
DX8Wrapper::Set_Material(VertexMaterials[Polys[start_index].I]);
DX8Wrapper::Set_Shader(Shaders[start_index]);
int next_index = start_index;
while ( (next_index < Polys.Count()) &&
(Textures[next_index] == Textures[start_index]) &&
(Shaders[next_index] == Shaders[start_index]) &&
(VertexMaterials[next_index] == VertexMaterials[start_index]))
{
next_index++;
}
return next_index;
}
/***********************************************************************************************
* RigidDecalMeshClass::Create_Decal -- Generate a new decal *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* All Decals on a mesh must be generated from the same DecalSystemClass! *
* *
* HISTORY: *
* 1/26/00 gth : Created. *
*=============================================================================================*/
bool RigidDecalMeshClass::Create_Decal
(
DecalGeneratorClass * generator,
const OBBoxClass & localbox,
SimpleDynVecClass<uint32> & apt,
const DynamicVectorClass<Vector3> * world_vertex_locs
)
{
// Since we can't rely on the hardware polygon offset function, I'm physically offsetting
// the decal polygons along the normal of the decal generator. If we could instead rely
// on hardware "polygon offset" we could remove this code and we could make decals non-sorting
Vector3 zbias_offset(0.0f,0.0f,0.0f);
if (!DX8Wrapper::Get_Current_Caps()->Support_ZBias()) {
const float ZBIAS_DISTANCE = 0.01f;
generator->Get_Transform().Get_Z_Vector(&zbias_offset);
Matrix3D invtm;
Parent->Get_Transform().Get_Orthogonal_Inverse(invtm);
Matrix3D::Rotate_Vector(invtm,zbias_offset,&zbias_offset);
zbias_offset *= ZBIAS_DISTANCE;
}
// NOTE: world_vertex_locs/norms should not be set for this class
WWASSERT(world_vertex_locs == 0);
int i,j;
WWASSERT(generator->Peek_Decal_System() == DecalSystem);
/*
** If any polys were collected, add a new MeshDecalStruct
*/
if (apt.Count() == 0) {
return false;
}
DecalStruct newdecal;
newdecal.DecalID = generator->Get_Decal_ID();
newdecal.FaceStartIndex = Polys.Count(); // start faces at the end of the current array
newdecal.FaceCount = 0; // init facecount to zero
newdecal.VertexStartIndex = Verts.Count(); // start vertices at the end of the current array
newdecal.VertexCount = 0; // init vertcount to zero
/*
** Grab pointers to the parent mesh's components
*/
MeshModelClass * model = Parent->Peek_Model();
const TriIndex * src_polys = model->Get_Polygon_Array();
const Vector3 * src_verts = model->Get_Vertex_Array();
const Vector3 * src_vnorms = model->Get_Vertex_Normal_Array();
/*
** Grab a pointer to the material settings
*/
MaterialPassClass * material = generator->Get_Material();
/*
** Set up the generator for our coordinate system
*/
generator->Set_Mesh_Transform(Parent->Get_Transform());
/*
** Compute the clipping planes
*/
PlaneClass planes[4];
Vector3 extent;
Matrix3::Rotate_Vector(localbox.Basis,Vector3(localbox.Extent.X,0,0),&extent);
Vector3 direction(localbox.Basis.Get_X_Vector());
planes[0].Set(-direction,localbox.Center + extent);
planes[1].Set(direction,localbox.Center - extent);
Matrix3::Rotate_Vector(localbox.Basis,Vector3(0,localbox.Extent.Y,0),&extent);
direction.Set(localbox.Basis.Get_Y_Vector());
planes[2].Set(-direction,localbox.Center + extent);
planes[3].Set(direction,localbox.Center - extent);
/*
** Generate the faces and per-face info
*/
bool added_polys = false;
Vector3 pdir = localbox.Basis.Get_Z_Vector();
for (i=0; i<apt.Count(); i++) {
/*
** check if the polygon is backfacing
*/
PlaneClass plane;
model->Compute_Plane(apt[i],&plane);
float dot = Vector3::Dot_Product(plane.N,pdir);
if (dot > generator->Get_Backface_Threshhold()) {
/*
** Copy src_polys[apt[i]] into our clip polygon
*/
_DecalPoly0.Reset();
const TriIndex & poly = src_polys[apt[i]];
for (j=0; j<3; j++) {
_DecalPoly0.Add_Vertex(src_verts[poly[j]] + zbias_offset,src_vnorms[poly[j]]);
}
/*
** Clip against the edges of the bounding box
*/
_DecalPoly0.Clip(planes[0],_DecalPoly1);
_DecalPoly1.Clip(planes[1],_DecalPoly0);
_DecalPoly0.Clip(planes[2],_DecalPoly1);
_DecalPoly1.Clip(planes[3],_DecalPoly0);
/*
** Check if the clipped polygon is empty or degenerate
*/
if (_DecalPoly0.Verts.Count() >= 3) {
/*
** Extract triangles from the clipped polygon
*/
int first_vert = Verts.Count();
for (j=1; j<_DecalPoly0.Verts.Count()-1; j++) {
/*
** Check if this triangle is degenerate (Sutherland-Hodgeman can sometimes create degenerate tris)
*/
// TODO
/*
** Add the triangle, its plane equation, and the per-tri materials
*/
added_polys = true;
Polys.Add(TriIndex(first_vert,first_vert + j,first_vert + j + 1));
Shaders.Add(material->Peek_Shader());
Textures.Add(material->Get_Texture()); // Get_Texture gives us a reference...
}
/*
** Extract verts from the clipped polygon
*/
for (j=0; j<_DecalPoly0.Verts.Count(); j++) {
Verts.Add(_DecalPoly0.Verts[j]);
_DecalPoly0.VertNorms[j].Normalize();
VertNorms.Add(_DecalPoly0.VertNorms[j]);
VertexMaterials.Add(material->Get_Material()); // Get_Material gives us a ref.
/*
** Compute the uv coordinates for this vertex
*/
Vector3 stq;
generator->Compute_Texture_Coordinate(Verts[Verts.Count()-1],&stq);
TexCoords.Add(Vector2(stq.X,stq.Y));
}
}
}
}
if (added_polys) {
newdecal.FaceCount = Polys.Count() - newdecal.FaceStartIndex;
newdecal.VertexCount = Verts.Count() - newdecal.VertexStartIndex;
Decals.Add(newdecal);
/*
** tell the generator that we added a decal
*/
generator->Add_Mesh(Parent);
}
material->Release_Ref();
#ifdef WWDEBUG
/*
** Some paranoid debug code: ensure all tris have valid vertex indices
*/
int poly_count = Polys.Count();
int vert_count = Verts.Count();
for (int poly_idx = 0; poly_idx < poly_count; poly_idx++) {
WWASSERT (Polys[poly_idx].I < vert_count);
WWASSERT (Polys[poly_idx].I >= 0);
WWASSERT (Polys[poly_idx].J < vert_count);
WWASSERT (Polys[poly_idx].J >= 0);
WWASSERT (Polys[poly_idx].K < vert_count);
WWASSERT (Polys[poly_idx].K >= 0);
}
#endif
/*
** Only return true if we actually added a decal
*/
return added_polys;
}
/***********************************************************************************************
* RigidDecalMeshClass::Delete_Decal -- Delete a decal *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/26/00 gth : Created. *
*=============================================================================================*/
bool RigidDecalMeshClass::Delete_Decal(uint32 id)
{
/*
** Find the MeshDecal which matches the given id
*/
int decal_index = -1;
for (int i = 0;i < Decals.Count(); i++) {
if (Decals[i].DecalID == id) {
decal_index = i;
break;
}
}
if (decal_index == -1) {
return false;
}
DecalStruct * decal = &Decals[decal_index];
/*
** Remove all geometry used by this decal
*/
Polys.Delete_Range(decal->FaceStartIndex,decal->FaceCount);
Verts.Delete_Range(decal->VertexStartIndex,decal->VertexCount);
VertNorms.Delete_Range(decal->VertexStartIndex,decal->VertexCount);
TexCoords.Delete_Range(decal->VertexStartIndex,decal->VertexCount);
/*
** Re-index the remaining triangle vertex indices
*/
for (int poly_index = 0; poly_index < Polys.Count(); poly_index++) {
if (Polys[poly_index].I > decal->VertexStartIndex) Polys[poly_index].I -= decal->VertexCount;
if (Polys[poly_index].J > decal->VertexStartIndex) Polys[poly_index].J -= decal->VertexCount;
if (Polys[poly_index].K > decal->VertexStartIndex) Polys[poly_index].K -= decal->VertexCount;
}
/*
** Remove all materials used by this decal (remember to release refs!)
*/
for (int fi=decal->FaceStartIndex; fi<decal->FaceCount; fi++) {
REF_PTR_RELEASE(Textures[fi]);
}
for (int vi=decal->VertexStartIndex; vi<decal->VertexCount; vi++) {
REF_PTR_RELEASE(VertexMaterials[vi]);
}
Shaders.Delete_Range(decal->FaceStartIndex,decal->FaceCount);
Textures.Delete_Range(decal->FaceStartIndex,decal->FaceCount);
VertexMaterials.Delete_Range(decal->VertexStartIndex,decal->VertexCount);
/*
** Remove MeshDecal and refresh all other decal indices
*/
for (int di=decal_index+1; di<Decals.Count(); di++) {
Decals[di].FaceStartIndex -= decal->FaceCount;
Decals[di].VertexStartIndex -= decal->VertexCount;
}
Decals.Delete(decal_index);
#ifdef WWDEBUG
/*
** Some paranoid debug code: ensure all tris have valid vertex indices
*/
int poly_count = Polys.Count();
int vert_count = Verts.Count();
for (int poly_idx = 0; poly_idx < poly_count; poly_idx++) {
WWASSERT (Polys[poly_idx].I < vert_count);
WWASSERT (Polys[poly_idx].I >= 0);
WWASSERT (Polys[poly_idx].J < vert_count);
WWASSERT (Polys[poly_idx].J >= 0);
WWASSERT (Polys[poly_idx].K < vert_count);
WWASSERT (Polys[poly_idx].K >= 0);
}
#endif
return true;
}
/*
** Temporary Buffers
** These buffers are used by the skin code for temporary storage of the deformed vertices and
** vertex normals.
*/
static SimpleVecClass<Vector3> _TempVertexBuffer;
static SimpleVecClass<Vector3> _TempNormalBuffer;
/*
** SkinDecalMeshClass Implementation
*/
/***********************************************************************************************
* SkinDecalMeshClass::SkinDecalMeshClass -- Constructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
SkinDecalMeshClass::SkinDecalMeshClass(MeshClass * parent, DecalSystemClass * system) :
DecalMeshClass(parent, system)
{
}
/***********************************************************************************************
* SkinDecalMeshClass::~SkinDecalMeshClass -- Destructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
SkinDecalMeshClass::~SkinDecalMeshClass(void)
{
int i;
// Notify the system that this decal mesh is being destroyed.
for (i=0; i<Decals.Count(); i++) {
DecalSystem->Decal_Mesh_Destroyed(Decals[i].DecalID,this);
}
// Release all of our references. The memory in the arrays will automatically be
// released by the SimpleDynVecClass...
for (i=0; i<Polys.Count(); i++) {
REF_PTR_RELEASE(Textures[i]);
}
for (i=0; i<ParentVertexIndices.Count(); i++) {
REF_PTR_RELEASE(VertexMaterials[i]);
}
}
/***********************************************************************************************
* SkinDecalMeshClass::Render -- Render the decals *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
void SkinDecalMeshClass::Render(void)
{
if ((Decals.Count() == 0) || (WW3D::Are_Decals_Enabled() == false)) return;
/*
** Don't allow decals on sorted meshes
*/
MeshModelClass * model = Parent->Peek_Model();
if (model->Get_Flag(MeshModelClass::SORT)) {
WWDEBUG_SAY(("ERROR: decals applied to a sorted mesh!\n"));
return;
}
/*
** Skin decals coordinates are in world space
*/
DX8Wrapper::Set_Transform(D3DTS_WORLD,Matrix3D::Identity);
/*
** Skin decals have to get the deformed vertices of their parent meshes. For this
** reason, decals on skins is not a very good idea...
*/
_TempVertexBuffer.Uninitialised_Grow(model->Get_Vertex_Count());
_TempNormalBuffer.Uninitialised_Grow(model->Get_Vertex_Count());
Parent->Get_Deformed_Vertices(&(_TempVertexBuffer[0]),&(_TempNormalBuffer[0]));
/*
** Copy the vertices into the dynamic vb
*/
DynamicVBAccessClass dynamic_vb(BUFFER_TYPE_DYNAMIC_DX8,dynamic_fvf_type,ParentVertexIndices.Count());
{
DynamicVBAccessClass::WriteLockClass lock(&dynamic_vb);
VertexFormatXYZNDUV2 * vertex = lock.Get_Formatted_Vertex_Array();
for (int i=0; i<ParentVertexIndices.Count(); i++) {
int src_i = ParentVertexIndices[i];
vertex->x = _TempVertexBuffer[src_i].X;
vertex->y = _TempVertexBuffer[src_i].Y;
vertex->z = _TempVertexBuffer[src_i].Z;
vertex->nx = _TempNormalBuffer[src_i].X;
vertex->ny = _TempNormalBuffer[src_i].Y;
vertex->nz = _TempNormalBuffer[src_i].Z;
vertex->diffuse = 0xFFFFFFFF;
vertex->u1 = TexCoords[i].X;
vertex->v1 = TexCoords[i].Y;
vertex->u2 = 0.0f;
vertex->v2 = 0.0f;
vertex++;
}
}
/*
** Copy the indices into the dynamic ib
*/
DynamicIBAccessClass dynamic_ib(BUFFER_TYPE_DYNAMIC_DX8,Polys.Count() * 3);
{
DynamicIBAccessClass::WriteLockClass lock(&dynamic_ib);
unsigned short * indices = lock.Get_Index_Array();
for (int i=0; i < Polys.Count(); i++)
{
indices[i*3 + 0] = (unsigned short)Polys[i].I;
indices[i*3 + 1] = (unsigned short)Polys[i].J;
indices[i*3 + 2] = (unsigned short)Polys[i].K;
}
}
/*
** Render in runs of constant material settings
*/
int cur_poly_index = 0;
int next_poly_index = 0;
while (next_poly_index < Polys.Count()) {
next_poly_index = Process_Material_Run(cur_poly_index);
DX8Wrapper::Set_Index_Buffer(dynamic_ib,0);
DX8Wrapper::Set_Vertex_Buffer(dynamic_vb);
DX8Wrapper::Draw_Triangles(3*cur_poly_index,
(next_poly_index - cur_poly_index), // poly count
Polys[cur_poly_index].I,
1 + Polys[next_poly_index-1].K - Polys[cur_poly_index].I);
cur_poly_index = next_poly_index;
}
}
/***********************************************************************************************
* SkinDecalMeshClass::Process_Material_Run -- scans the mesh for material runs *
* *
* This function will install the materials for poly[start_index] and scan forward for *
* the next material change. It will return the start index for the next material change *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 2/22/2001 gth : Created. *
*=============================================================================================*/
int SkinDecalMeshClass::Process_Material_Run(int start_index)
{
DX8Wrapper::Set_Texture(0,Textures[start_index]);
DX8Wrapper::Set_Material(VertexMaterials[Polys[start_index].I]);
DX8Wrapper::Set_Shader(Shaders[start_index]);
int next_index = start_index;
while ( (next_index < Polys.Count()) &&
(Textures[next_index] == Textures[start_index]) &&
(Shaders[next_index] == Shaders[start_index]) &&
(VertexMaterials[next_index] == VertexMaterials[start_index]))
{
next_index++;
}
return next_index;
}
/***********************************************************************************************
* SkinDecalMeshClass::Create_Decal -- Generate a new decal *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* All Decals on a mesh must be generated from the same DecalSystemClass! *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
bool SkinDecalMeshClass::Create_Decal(DecalGeneratorClass * generator,
const OBBoxClass & localbox, SimpleDynVecClass<uint32> & apt,
const DynamicVectorClass<Vector3> * world_vertex_locs)
{
int i;
WWASSERT(generator->Peek_Decal_System() == DecalSystem);
// The dynamically updated vertex locations are needed - we have no static geometry
WWASSERT(world_vertex_locs);
/*
** If any polys were collected, add a new MeshDecalStruct
*/
if (apt.Count() == 0) {
return false;
}
DecalStruct newdecal;
newdecal.DecalID = generator->Get_Decal_ID();
newdecal.FaceStartIndex = Polys.Count(); // start faces at the end of the current array
newdecal.FaceCount = 0; // init facecount to zero
newdecal.VertexStartIndex = ParentVertexIndices.Count(); // start vertices at the end of the current array
newdecal.VertexCount = 0; // init vertcount to zero
/*
** Grab pointers to the parent mesh's components
*/
MeshModelClass * model = Parent->Peek_Model();
const TriIndex * src_polys = model->Get_Polygon_Array();
/*
** Grab a pointer to the material settings
*/
MaterialPassClass * material = generator->Get_Material();
/*
** Set up the generator for the world coordinate system (the deformed vertices are in worldspace)
*/
generator->Set_Mesh_Transform(Matrix3D::Identity);
/*
** Generate the faces and per-face info (remember to add-ref's)
** TODO: rewrite this to take advantage of vertex sharing...
*/
int face_size_hint = Polys.Count() + apt.Count();
int first_vert = ParentVertexIndices.Count();
for (i = 0; i < apt.Count(); i++) {
int offset = first_vert + i * 3;
Polys.Add(TriIndex(offset, offset + 1, offset + 2), face_size_hint);
Shaders.Add(material->Peek_Shader(), face_size_hint);
Textures.Add(material->Get_Texture(), face_size_hint); // Get_Texture gives us a reference...
}
/*
** Copy the vertices and per-vertex info
** TODO: rewrite this to take advantage of vertex sharing...
*/
int vertex_size_hint = ParentVertexIndices.Count() + 3 * apt.Count();
for (i = 0; i < apt.Count(); i++) {
int face_index = apt[i];
for (int vi = 0; vi < 3; vi++) {
/*
** Copy data for this vertex
*/
ParentVertexIndices.Add(src_polys[face_index][vi], vertex_size_hint);
VertexMaterials.Add(material->Get_Material(), vertex_size_hint); // Get_Material gives us a ref.
/*
** Compute the uv coordinates for this vertex
*/
Vector3 stq;
generator->Compute_Texture_Coordinate((*world_vertex_locs)[ParentVertexIndices[ParentVertexIndices.Count() - 1]], &stq);
TexCoords.Add(Vector2(stq.X,stq.Y));
}
}
newdecal.FaceCount = Polys.Count() - newdecal.FaceStartIndex;
newdecal.VertexCount = ParentVertexIndices.Count() - newdecal.VertexStartIndex;
Decals.Add(newdecal);
material->Release_Ref();
/*
** tell the generator that we added a MeshDecal
*/
generator->Add_Mesh(Parent);
#ifdef WWDEBUG
/*
** Some paranoid debug code: ensure all tris have valid vertex indices
*/
int poly_count = Polys.Count();
int vert_count = ParentVertexIndices.Count();
for (int poly_idx = 0; poly_idx < poly_count; poly_idx++) {
WWASSERT (Polys[poly_idx].I < vert_count);
WWASSERT (Polys[poly_idx].I >= 0);
WWASSERT (Polys[poly_idx].J < vert_count);
WWASSERT (Polys[poly_idx].J >= 0);
WWASSERT (Polys[poly_idx].K < vert_count);
WWASSERT (Polys[poly_idx].K >= 0);
}
#endif
// WWDEBUG_SAY(("Decal mesh now has: %d polys\r\n",Polys.Count()));
return true;
}
/***********************************************************************************************
* SkinDecalMeshClass::Delete_Decal -- Delete a decal *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 1/31/00 NH : Created. *
*=============================================================================================*/
bool SkinDecalMeshClass::Delete_Decal(uint32 id)
{
/*
** Find the MeshDecal which matches the given id
*/
int decal_index = -1;
for (int i = 0;i < Decals.Count(); i++) {
if (Decals[i].DecalID == id) {
decal_index = i;
break;
}
}
if (decal_index == -1) {
return false;
}
DecalStruct * decal = &Decals[decal_index];
/*
** Remove all geometry used by this decal
*/
Polys.Delete_Range(decal->FaceStartIndex, decal->FaceCount);
ParentVertexIndices.Delete_Range(decal->VertexStartIndex, decal->VertexCount);
TexCoords.Delete_Range(decal->VertexStartIndex, decal->VertexCount);
/*
** Re-index the remaining triangle vertex indices
*/
for (int poly_index = 0; poly_index < Polys.Count(); poly_index++) {
if (Polys[poly_index].I > decal->VertexStartIndex) Polys[poly_index].I -= decal->VertexCount;
if (Polys[poly_index].J > decal->VertexStartIndex) Polys[poly_index].J -= decal->VertexCount;
if (Polys[poly_index].K > decal->VertexStartIndex) Polys[poly_index].K -= decal->VertexCount;
}
/*
** Remove all materials used by this decal (remember to release refs!)
*/
for (int fi = decal->FaceStartIndex; fi < decal->FaceCount; fi++) {
REF_PTR_RELEASE(Textures[fi]);
}
for (int vi=decal->VertexStartIndex; vi<decal->VertexCount; vi++) {
REF_PTR_RELEASE(VertexMaterials[vi]);
}
Shaders.Delete_Range(decal->FaceStartIndex,decal->FaceCount);
Textures.Delete_Range(decal->FaceStartIndex,decal->FaceCount);
VertexMaterials.Delete_Range(decal->VertexStartIndex,decal->VertexCount);
/*
** Remove MeshDecal and refresh all other decal indices
*/
for (int di=decal_index+1; di<Decals.Count(); di++) {
Decals[di].FaceStartIndex -= decal->FaceCount;
Decals[di].VertexStartIndex -= decal->VertexCount;
}
Decals.Delete(decal_index);
#ifdef WWDEBUG
/*
** Some paranoid debug code: ensure all tris have valid vertex indices
*/
int poly_count = Polys.Count();
int vert_count = ParentVertexIndices.Count();
for (int poly_idx = 0; poly_idx < poly_count; poly_idx++) {
WWASSERT (Polys[poly_idx].I < vert_count);
WWASSERT (Polys[poly_idx].I >= 0);
WWASSERT (Polys[poly_idx].J < vert_count);
WWASSERT (Polys[poly_idx].J >= 0);
WWASSERT (Polys[poly_idx].K < vert_count);
WWASSERT (Polys[poly_idx].K >= 0);
}
#endif
return true;
}
Reference in a new issue View git blame Copy permalink