1110 lines
44 KiB
C++
1110 lines
44 KiB
C++
/*
|
|
** 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;
|
|
}
|