2102 lines
62 KiB
C++
2102 lines
62 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/dx8renderer.cpp $*
|
|
* *
|
|
* Original Author:: Greg Hjelstrom *
|
|
* *
|
|
* $Author:: Greg_h $*
|
|
* *
|
|
* $Modtime:: 2/28/02 5:35p $*
|
|
* *
|
|
* $Revision:: 111 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
//#define ENABLE_CATEGORY_LOG
|
|
//#define ENABLE_STRIPING
|
|
|
|
#include "dx8renderer.h"
|
|
#include "dx8wrapper.h"
|
|
#include "dx8polygonrenderer.h"
|
|
#include "dx8vertexbuffer.h"
|
|
#include "dx8indexbuffer.h"
|
|
#include "dx8fvf.h"
|
|
#include "dx8caps.h"
|
|
#include "dx8rendererdebugger.h"
|
|
#include "wwdebug.h"
|
|
#include "wwprofile.h"
|
|
#include "wwmemlog.h"
|
|
#include "rinfo.h"
|
|
#include "statistics.h"
|
|
#include "meshmdl.h"
|
|
#include "vp.h"
|
|
#include "decalmsh.h"
|
|
#include "matpass.h"
|
|
#include "camera.h"
|
|
#include "stripoptimizer.h"
|
|
#include "meshgeometry.h"
|
|
#include "hashtemplate.h"
|
|
|
|
|
|
/*
|
|
** Global Instance of the DX8MeshRender
|
|
*/
|
|
DX8MeshRendererClass TheDX8MeshRenderer;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static DynamicVectorClass<Vector3> _TempVertexBuffer;
|
|
static DynamicVectorClass<Vector3> _TempNormalBuffer;
|
|
|
|
static TextureCategoryList texture_category_delete_list;
|
|
static FVFCategoryList fvf_category_container_delete_list;
|
|
|
|
|
|
// helper data structure
|
|
class PolyRemover : public MultiListObjectClass
|
|
{
|
|
public:
|
|
DX8TextureCategoryClass * src;
|
|
DX8TextureCategoryClass * dest;
|
|
DX8PolygonRendererClass * pr;
|
|
};
|
|
|
|
typedef MultiListClass<PolyRemover> PolyRemoverList;
|
|
typedef MultiListIterator<PolyRemover> PolyRemoverListIterator;
|
|
|
|
|
|
/**
|
|
** PolyRenderTaskClass
|
|
** This is a record of a polyrendere that needs to be rendered
|
|
** for this frame. Since MeshClass instances can share meshmodels
|
|
** (and therefore their dx8 polygon renderers) this record contains
|
|
** a pointer to the polygon renderer and the MeshClass instance that
|
|
** it is being rendered for.
|
|
*/
|
|
class PolyRenderTaskClass : public AutoPoolClass<PolyRenderTaskClass, 256>
|
|
{
|
|
public:
|
|
PolyRenderTaskClass(DX8PolygonRendererClass * p_renderer,MeshClass * p_mesh) :
|
|
Renderer(p_renderer),
|
|
Mesh(p_mesh),
|
|
NextVisible(NULL)
|
|
{
|
|
WWASSERT(Renderer != NULL);
|
|
WWASSERT(Mesh != NULL);
|
|
Mesh->Add_Ref();
|
|
}
|
|
|
|
~PolyRenderTaskClass(void)
|
|
{
|
|
Mesh->Release_Ref();
|
|
}
|
|
|
|
DX8PolygonRendererClass * Peek_Polygon_Renderer(void) { return Renderer; }
|
|
MeshClass * Peek_Mesh(void) { return Mesh; }
|
|
|
|
PolyRenderTaskClass * Get_Next_Visible(void) { return NextVisible; }
|
|
void Set_Next_Visible(PolyRenderTaskClass * prtc) { NextVisible = prtc; }
|
|
|
|
protected:
|
|
|
|
DX8PolygonRendererClass * Renderer;
|
|
MeshClass * Mesh;
|
|
PolyRenderTaskClass * NextVisible;
|
|
|
|
};
|
|
|
|
DEFINE_AUTO_POOL(PolyRenderTaskClass, 256);
|
|
|
|
/**
|
|
** MatPassTaskClass
|
|
** This is the record of a material pass that needs to be rendered on
|
|
** a particular mesh. These are linked into the FVF container which
|
|
** contains the mesh model. They are also pooled to remove memory
|
|
** allocation overhead.
|
|
*/
|
|
class MatPassTaskClass : public AutoPoolClass<MatPassTaskClass, 256>
|
|
{
|
|
public:
|
|
MatPassTaskClass(MaterialPassClass * pass,MeshClass * mesh) :
|
|
MaterialPass(pass),
|
|
Mesh(mesh),
|
|
NextVisible(NULL)
|
|
{
|
|
WWASSERT(MaterialPass != NULL);
|
|
WWASSERT(Mesh != NULL);
|
|
MaterialPass->Add_Ref();
|
|
Mesh->Add_Ref();
|
|
}
|
|
|
|
~MatPassTaskClass(void)
|
|
{
|
|
MaterialPass->Release_Ref();
|
|
Mesh->Release_Ref();
|
|
}
|
|
|
|
MaterialPassClass * Peek_Material_Pass(void) { return MaterialPass; }
|
|
MeshClass * Peek_Mesh(void) { return Mesh; }
|
|
|
|
MatPassTaskClass * Get_Next_Visible(void) { return NextVisible; }
|
|
void Set_Next_Visible(MatPassTaskClass * mpr) { NextVisible = mpr; }
|
|
|
|
private:
|
|
|
|
MaterialPassClass * MaterialPass;
|
|
MeshClass * Mesh;
|
|
MatPassTaskClass * NextVisible;
|
|
};
|
|
|
|
DEFINE_AUTO_POOL(MatPassTaskClass, 256);
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
inline static bool Equal_Material(const VertexMaterialClass* mat1,const VertexMaterialClass* mat2)
|
|
{
|
|
int crc0 = mat1 ? mat1->Get_CRC() : 0;
|
|
int crc1 = mat2 ? mat2->Get_CRC() : 0;
|
|
return (crc0 == crc1);
|
|
}
|
|
|
|
|
|
DX8TextureCategoryClass::DX8TextureCategoryClass(
|
|
DX8FVFCategoryContainer* container_,
|
|
TextureClass** texs,
|
|
ShaderClass shd,
|
|
VertexMaterialClass* mat,
|
|
int pass_)
|
|
:
|
|
pass(pass_),
|
|
shader(shd),
|
|
render_task_head(NULL),
|
|
material(mat),
|
|
container(container_)
|
|
{
|
|
WWASSERT(pass>=0);
|
|
WWASSERT(pass<DX8FVFCategoryContainer::MAX_PASSES);
|
|
|
|
for (int a=0;a<MAX_TEXTURE_STAGES;++a) {
|
|
textures[a]=NULL;
|
|
REF_PTR_SET(textures[a],texs[a]);
|
|
}
|
|
|
|
if (material) material->Add_Ref();
|
|
}
|
|
|
|
DX8TextureCategoryClass::~DX8TextureCategoryClass()
|
|
{
|
|
// Unregistering the mesh where polygon renderers are connected to kills all polygon renderers
|
|
while (DX8PolygonRendererClass* p_renderer=PolygonRendererList.Get_Head()) {
|
|
TheDX8MeshRenderer.Unregister_Mesh_Type(p_renderer->Get_Mesh_Class());
|
|
}
|
|
for (int a=0;a<MAX_TEXTURE_STAGES;++a) {
|
|
REF_PTR_RELEASE(textures[a]);
|
|
}
|
|
|
|
REF_PTR_RELEASE(material);
|
|
}
|
|
|
|
void DX8TextureCategoryClass::Add_Render_Task(DX8PolygonRendererClass * p_renderer,MeshClass * p_mesh)
|
|
{
|
|
PolyRenderTaskClass * new_prt = new PolyRenderTaskClass(p_renderer,p_mesh);
|
|
new_prt->Set_Next_Visible(render_task_head);
|
|
render_task_head = new_prt;
|
|
|
|
container->Add_Visible_Texture_Category(this,pass);
|
|
}
|
|
|
|
void DX8TextureCategoryClass::Add_Polygon_Renderer(DX8PolygonRendererClass* p_renderer,DX8PolygonRendererClass* add_after_this)
|
|
{
|
|
WWASSERT(p_renderer!=NULL);
|
|
WWASSERT(!PolygonRendererList.Contains(p_renderer));
|
|
|
|
if (add_after_this != NULL) {
|
|
bool res = PolygonRendererList.Add_After(p_renderer,add_after_this,false);
|
|
WWASSERT(res != NULL);
|
|
} else {
|
|
PolygonRendererList.Add(p_renderer);
|
|
}
|
|
|
|
p_renderer->Set_Texture_Category(this);
|
|
}
|
|
|
|
void DX8TextureCategoryClass::Remove_Polygon_Renderer(DX8PolygonRendererClass* p_renderer)
|
|
{
|
|
PolygonRendererList.Remove(p_renderer);
|
|
p_renderer->Set_Texture_Category(NULL);
|
|
if (PolygonRendererList.Peek_Head() == NULL) {
|
|
container->Remove_Texture_Category(this);
|
|
texture_category_delete_list.Add_Tail(this);
|
|
}
|
|
}
|
|
|
|
|
|
void DX8FVFCategoryContainer::Remove_Texture_Category(DX8TextureCategoryClass* tex_category)
|
|
{
|
|
for (unsigned pass=0;pass<passes;++pass) {
|
|
texture_category_list[pass].Remove(tex_category);
|
|
}
|
|
for (pass=0; pass<passes; pass++) {
|
|
// If any of the texture category lists has anything in it, no need to delete this container
|
|
if (texture_category_list[pass].Peek_Head() != NULL) return;
|
|
}
|
|
fvf_category_container_delete_list.Add_Tail(this);
|
|
}
|
|
|
|
void DX8FVFCategoryContainer::Add_Visible_Material_Pass(MaterialPassClass * pass,MeshClass * mesh)
|
|
{
|
|
MatPassTaskClass * new_mpr = new MatPassTaskClass(pass,mesh);
|
|
|
|
if (visible_matpass_head == NULL) {
|
|
WWASSERT(visible_matpass_tail == NULL);
|
|
visible_matpass_head = new_mpr;
|
|
} else {
|
|
WWASSERT(visible_matpass_tail != NULL);
|
|
visible_matpass_tail->Set_Next_Visible(new_mpr);
|
|
}
|
|
|
|
visible_matpass_tail = new_mpr;
|
|
AnythingToRender=true;
|
|
}
|
|
|
|
void DX8FVFCategoryContainer::Render_Procedural_Material_Passes(void)
|
|
{
|
|
// additional passes
|
|
MatPassTaskClass * mpr = visible_matpass_head;
|
|
while (mpr != NULL) {
|
|
|
|
mpr->Peek_Mesh()->Render_Material_Pass(mpr->Peek_Material_Pass(),index_buffer);
|
|
MatPassTaskClass * next_mpr = mpr->Get_Next_Visible();
|
|
|
|
delete mpr;
|
|
mpr = next_mpr;
|
|
}
|
|
|
|
visible_matpass_head = visible_matpass_tail = NULL;
|
|
}
|
|
|
|
void DX8RigidFVFCategoryContainer::Add_Delayed_Visible_Material_Pass(MaterialPassClass * pass, MeshClass * mesh)
|
|
{
|
|
MatPassTaskClass * new_mpr = new MatPassTaskClass(pass,mesh);
|
|
|
|
if (delayed_matpass_head == NULL) {
|
|
WWASSERT(delayed_matpass_tail == NULL);
|
|
delayed_matpass_head = new_mpr;
|
|
} else {
|
|
WWASSERT(delayed_matpass_tail != NULL);
|
|
delayed_matpass_tail->Set_Next_Visible(new_mpr);
|
|
}
|
|
|
|
delayed_matpass_tail = new_mpr;
|
|
AnyDelayedPassesToRender=true;
|
|
}
|
|
|
|
void DX8RigidFVFCategoryContainer::Render_Delayed_Procedural_Material_Passes(void)
|
|
{
|
|
if (!Any_Delayed_Passes_To_Render()) return;
|
|
AnyDelayedPassesToRender=false;
|
|
|
|
DX8Wrapper::Set_Vertex_Buffer(vertex_buffer);
|
|
DX8Wrapper::Set_Index_Buffer(index_buffer,0);
|
|
|
|
SNAPSHOT_SAY(("DX8RigidFVFCategoryContainer::Render_Delayed_Procedural_Material_Passes()\n"));
|
|
|
|
// additional passes
|
|
MatPassTaskClass * mpr = delayed_matpass_head;
|
|
while (mpr != NULL) {
|
|
|
|
mpr->Peek_Mesh()->Render_Material_Pass(mpr->Peek_Material_Pass(),index_buffer);
|
|
MatPassTaskClass * next_mpr = mpr->Get_Next_Visible();
|
|
|
|
delete mpr;
|
|
mpr = next_mpr;
|
|
}
|
|
|
|
delayed_matpass_head = delayed_matpass_tail = NULL;
|
|
}
|
|
|
|
|
|
void DX8TextureCategoryClass::Log(bool only_visible)
|
|
{
|
|
#ifdef ENABLE_CATEGORY_LOG
|
|
StringClass work(255,true);
|
|
work.Format(" DX8TextureCategoryClass\n");
|
|
WWDEBUG_SAY((work));
|
|
|
|
StringClass work2(255,true);
|
|
for (int stage=0;stage<MAX_TEXTURE_STAGES;++stage) {
|
|
work2.Format(" texture[%d]: %x (%s)\n", stage, textures[stage], textures[stage] ? textures[stage]->Get_Name() : "-");
|
|
work+=work2;
|
|
}
|
|
work2.Format(" material: %x (%s)\n shader: %x\n", material, material ? material->Get_Name() : "-", shader);
|
|
work+=work2;
|
|
WWDEBUG_SAY((work));
|
|
|
|
work.Format(" %8s %8s %6s %6s %6s %5s %s\n",
|
|
"idx_cnt",
|
|
"poly_cnt",
|
|
"i_offs",
|
|
"min_vi",
|
|
"vi_rng",
|
|
"ident",
|
|
"name");
|
|
WWDEBUG_SAY((work));
|
|
|
|
DX8PolygonRendererListIterator it(&PolygonRendererList);
|
|
while (!it.Is_Done()) {
|
|
|
|
DX8PolygonRendererClass* p_renderer = it.Peek_Obj();
|
|
|
|
PolyRenderTaskClass * prtc=render_task_head;
|
|
while (prtc) {
|
|
if (prtc->Peek_Polygon_Renderer()==p_renderer) break;
|
|
prtc = prtc->Get_Next_Visible();
|
|
}
|
|
|
|
if (prtc != NULL) {
|
|
WWDEBUG_SAY(("+"));
|
|
p_renderer->Log();
|
|
} else {
|
|
if (!only_visible) {
|
|
WWDEBUG_SAY(("-"));
|
|
p_renderer->Log();
|
|
}
|
|
}
|
|
it.Next();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8FVFCategoryContainer::DX8FVFCategoryContainer(unsigned FVF_,bool sorting_)
|
|
:
|
|
FVF(FVF_),
|
|
sorting(sorting_),
|
|
visible_matpass_head(NULL),
|
|
visible_matpass_tail(NULL),
|
|
index_buffer(0),
|
|
used_indices(0),
|
|
passes(MAX_PASSES),
|
|
uv_coordinate_channels(0),
|
|
AnythingToRender(false),
|
|
AnyDelayedPassesToRender(false)
|
|
{
|
|
if ((FVF&D3DFVF_TEX1)==D3DFVF_TEX1) uv_coordinate_channels=1;
|
|
if ((FVF&D3DFVF_TEX2)==D3DFVF_TEX2) uv_coordinate_channels=2;
|
|
if ((FVF&D3DFVF_TEX3)==D3DFVF_TEX3) uv_coordinate_channels=3;
|
|
if ((FVF&D3DFVF_TEX4)==D3DFVF_TEX4) uv_coordinate_channels=4;
|
|
if ((FVF&D3DFVF_TEX5)==D3DFVF_TEX5) uv_coordinate_channels=5;
|
|
if ((FVF&D3DFVF_TEX6)==D3DFVF_TEX6) uv_coordinate_channels=6;
|
|
if ((FVF&D3DFVF_TEX7)==D3DFVF_TEX7) uv_coordinate_channels=7;
|
|
if ((FVF&D3DFVF_TEX8)==D3DFVF_TEX8) uv_coordinate_channels=8;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8FVFCategoryContainer::~DX8FVFCategoryContainer()
|
|
{
|
|
REF_PTR_RELEASE(index_buffer);
|
|
|
|
for (unsigned p=0;p<passes;++p) {
|
|
while (DX8TextureCategoryClass * tex = texture_category_list[p].Remove_Head()) {
|
|
delete tex;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8TextureCategoryClass* DX8FVFCategoryContainer::Find_Matching_Texture_Category(
|
|
TextureClass* texture,
|
|
unsigned pass,
|
|
unsigned stage,
|
|
DX8TextureCategoryClass* ref_category)
|
|
{
|
|
// Find texture category which matches ref_category's properties but has 'texture' on given pass and stage.
|
|
DX8TextureCategoryClass* dest_tex_category=NULL;
|
|
TextureCategoryListIterator dest_it(&texture_category_list[pass]);
|
|
while (!dest_it.Is_Done()) {
|
|
if (dest_it.Peek_Obj()->Peek_Texture(stage)==texture) {
|
|
// Compare all stage's textures
|
|
dest_tex_category=dest_it.Peek_Obj();
|
|
bool all_textures_same = true;
|
|
for (unsigned int s = 0; s < MeshMatDescClass::MAX_TEX_STAGES; s++) {
|
|
if (stage!=s) {
|
|
all_textures_same = all_textures_same && (dest_tex_category->Peek_Texture(s) == ref_category->Peek_Texture(s));
|
|
}
|
|
}
|
|
if (all_textures_same &&
|
|
Equal_Material(dest_tex_category->Peek_Material(),ref_category->Peek_Material()) &&
|
|
dest_tex_category->Get_Shader()==ref_category->Get_Shader()) {
|
|
return dest_tex_category;
|
|
}
|
|
}
|
|
dest_it.Next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
DX8TextureCategoryClass* DX8FVFCategoryContainer::Find_Matching_Texture_Category(
|
|
VertexMaterialClass* vmat,
|
|
unsigned pass,
|
|
DX8TextureCategoryClass* ref_category)
|
|
{
|
|
// Find texture category which matches ref_category's properties but has 'vmat' on given pass
|
|
DX8TextureCategoryClass* dest_tex_category=NULL;
|
|
TextureCategoryListIterator dest_it(&texture_category_list[pass]);
|
|
while (!dest_it.Is_Done()) {
|
|
if (Equal_Material(dest_it.Peek_Obj()->Peek_Material(),vmat)) {
|
|
// Compare all stage's textures
|
|
dest_tex_category=dest_it.Peek_Obj();
|
|
bool all_textures_same = true;
|
|
for (unsigned int s = 0; s < MeshMatDescClass::MAX_TEX_STAGES; s++)
|
|
all_textures_same = all_textures_same && (dest_tex_category->Peek_Texture(s) == ref_category->Peek_Texture(s));
|
|
if (all_textures_same &&
|
|
dest_tex_category->Get_Shader()==ref_category->Get_Shader()) {
|
|
return dest_tex_category;
|
|
}
|
|
}
|
|
dest_it.Next();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void DX8FVFCategoryContainer::Change_Polygon_Renderer_Texture(
|
|
DX8PolygonRendererList& polygon_renderer_list,
|
|
TextureClass* texture,
|
|
TextureClass* new_texture,
|
|
unsigned pass,
|
|
unsigned stage)
|
|
{
|
|
WWASSERT(pass<passes);
|
|
|
|
PolyRemoverList prl;
|
|
|
|
bool foundtexture=false;
|
|
|
|
if (texture==new_texture) return;
|
|
|
|
// Find source texture category, then find all polygon renderers who belong to that category
|
|
// and move them to destination category.
|
|
TextureCategoryListIterator src_it(&texture_category_list[pass]);
|
|
while (!src_it.Is_Done()) {
|
|
DX8TextureCategoryClass* src_tex_category=src_it.Peek_Obj();
|
|
if (src_tex_category->Peek_Texture(stage)==texture) {
|
|
foundtexture=true;
|
|
DX8PolygonRendererListIterator poly_it(&polygon_renderer_list);
|
|
while (!poly_it.Is_Done()) {
|
|
// If source texture category contains polygon renderer, move to destination category
|
|
DX8PolygonRendererClass* polygon_renderer=poly_it.Peek_Obj();
|
|
DX8TextureCategoryClass *prc=polygon_renderer->Get_Texture_Category();
|
|
|
|
if (prc==src_tex_category) {
|
|
DX8TextureCategoryClass* dest_tex_category=Find_Matching_Texture_Category(new_texture,pass,stage,src_tex_category);
|
|
|
|
if (!dest_tex_category) {
|
|
TextureClass * tmp_textures[MeshMatDescClass::MAX_TEX_STAGES];
|
|
for (int s=0;s<MeshMatDescClass::MAX_TEX_STAGES;++s) {
|
|
tmp_textures[s]=src_tex_category->Peek_Texture(s);
|
|
}
|
|
tmp_textures[stage]=new_texture;
|
|
|
|
DX8TextureCategoryClass * new_tex_category=new DX8TextureCategoryClass(
|
|
this,
|
|
tmp_textures,
|
|
src_tex_category->Get_Shader(),
|
|
const_cast<VertexMaterialClass*>(src_tex_category->Peek_Material()),
|
|
pass);
|
|
|
|
/*
|
|
** Add the texture category object into the list, immediately after any existing
|
|
** texture category object which uses the same texture. This will result in
|
|
** the list always having matching texture categories next to each other.
|
|
*/
|
|
bool found_similar_category = false;
|
|
TextureCategoryListIterator tex_it(&texture_category_list[pass]);
|
|
while (!tex_it.Is_Done()) {
|
|
// Categorize according to first stage's texture for now
|
|
if (tex_it.Peek_Obj()->Peek_Texture(0) == tmp_textures[0]) {
|
|
texture_category_list[pass].Add_After(new_tex_category,tex_it.Peek_Obj());
|
|
found_similar_category = true;
|
|
break;
|
|
}
|
|
tex_it.Next();
|
|
}
|
|
|
|
if (!found_similar_category) {
|
|
texture_category_list[pass].Add_Tail(new_tex_category);
|
|
}
|
|
dest_tex_category=new_tex_category;
|
|
}
|
|
PolyRemover *rem=new PolyRemover;
|
|
rem->src=src_tex_category;
|
|
rem->dest=dest_tex_category;
|
|
rem->pr=polygon_renderer;
|
|
prl.Add(rem);
|
|
}
|
|
poly_it.Next();
|
|
} // while
|
|
} //if src_texture==texture
|
|
else
|
|
// quit loop if we've got a texture change
|
|
if (foundtexture) break;
|
|
src_it.Next();
|
|
} // while
|
|
|
|
PolyRemoverListIterator prli(&prl);
|
|
|
|
while (!prli.Is_Done())
|
|
{
|
|
PolyRemover *rem=prli.Peek_Obj();
|
|
rem->src->Remove_Polygon_Renderer(rem->pr);
|
|
rem->dest->Add_Polygon_Renderer(rem->pr);
|
|
prli.Remove_Current_Object();
|
|
delete rem;
|
|
}
|
|
}
|
|
|
|
void DX8FVFCategoryContainer::Change_Polygon_Renderer_Material(
|
|
DX8PolygonRendererList& polygon_renderer_list,
|
|
VertexMaterialClass* vmat,
|
|
VertexMaterialClass* new_vmat,
|
|
unsigned pass)
|
|
{
|
|
WWASSERT(pass<passes);
|
|
|
|
PolyRemoverList prl;
|
|
|
|
bool foundtexture=false;
|
|
|
|
if (vmat==new_vmat) return;
|
|
|
|
// Find source texture category, then find all polygon renderers who belong to that category
|
|
// and move them to destination category.
|
|
TextureCategoryListIterator src_it(&texture_category_list[pass]);
|
|
while (!src_it.Is_Done()) {
|
|
DX8TextureCategoryClass* src_tex_category=src_it.Peek_Obj();
|
|
if (src_tex_category->Peek_Material()==vmat) {
|
|
DX8PolygonRendererListIterator poly_it(&polygon_renderer_list);
|
|
while (!poly_it.Is_Done()) {
|
|
// If source texture category contains polygon renderer, move to destination category
|
|
DX8PolygonRendererClass* polygon_renderer=poly_it.Peek_Obj();
|
|
DX8TextureCategoryClass *prc=polygon_renderer->Get_Texture_Category();
|
|
if (prc==src_tex_category) {
|
|
foundtexture=true;
|
|
DX8TextureCategoryClass* dest_tex_category=Find_Matching_Texture_Category(new_vmat,pass,src_tex_category);
|
|
|
|
if (!dest_tex_category) {
|
|
TextureClass * tmp_textures[MeshMatDescClass::MAX_TEX_STAGES];
|
|
for (int s=0;s<MeshMatDescClass::MAX_TEX_STAGES;++s) {
|
|
tmp_textures[s]=src_tex_category->Peek_Texture(s);
|
|
}
|
|
|
|
DX8TextureCategoryClass * new_tex_category=new DX8TextureCategoryClass(
|
|
this,
|
|
tmp_textures,
|
|
src_tex_category->Get_Shader(),
|
|
const_cast<VertexMaterialClass*>(new_vmat),
|
|
pass);
|
|
|
|
/*
|
|
** Add the texture category object into the list, immediately after any existing
|
|
** texture category object which uses the same texture. This will result in
|
|
** the list always having matching texture categories next to each other.
|
|
*/
|
|
bool found_similar_category = false;
|
|
TextureCategoryListIterator tex_it(&texture_category_list[pass]);
|
|
while (!tex_it.Is_Done()) {
|
|
// Categorize according to first stage's texture for now
|
|
if (tex_it.Peek_Obj()->Peek_Texture(0) == tmp_textures[0]) {
|
|
texture_category_list[pass].Add_After(new_tex_category,tex_it.Peek_Obj());
|
|
found_similar_category = true;
|
|
break;
|
|
}
|
|
tex_it.Next();
|
|
}
|
|
|
|
if (!found_similar_category) {
|
|
texture_category_list[pass].Add_Tail(new_tex_category);
|
|
}
|
|
dest_tex_category=new_tex_category;
|
|
}
|
|
PolyRemover *rem=new PolyRemover;
|
|
rem->src=src_tex_category;
|
|
rem->dest=dest_tex_category;
|
|
rem->pr=polygon_renderer;
|
|
prl.Add(rem);
|
|
}
|
|
poly_it.Next();
|
|
} // while
|
|
} // if
|
|
else
|
|
if (foundtexture) break;
|
|
src_it.Next();
|
|
} // while
|
|
|
|
PolyRemoverListIterator prli(&prl);
|
|
|
|
while (!prli.Is_Done())
|
|
{
|
|
PolyRemover *rem=prli.Peek_Obj();
|
|
rem->src->Remove_Polygon_Renderer(rem->pr);
|
|
rem->dest->Add_Polygon_Renderer(rem->pr);
|
|
prli.Remove_Current_Object();
|
|
delete rem;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned DX8FVFCategoryContainer::Define_FVF(MeshModelClass* mmc,unsigned int * user_lighting,bool enable_lighting)
|
|
{
|
|
if ((!!mmc->Get_Flag(MeshGeometryClass::SORT)) && WW3D::Is_Sorting_Enabled()) {
|
|
return dynamic_fvf_type;
|
|
}
|
|
|
|
unsigned fvf=D3DFVF_XYZ;
|
|
|
|
int tex_coord_count=mmc->Get_UV_Array_Count();
|
|
|
|
if (mmc->Get_Color_Array(0,false) || (user_lighting != NULL)) {
|
|
fvf|=D3DFVF_DIFFUSE;
|
|
}
|
|
if (mmc->Get_Color_Array(1,false)) {
|
|
fvf|=D3DFVF_SPECULAR;
|
|
}
|
|
|
|
switch (tex_coord_count) {
|
|
default:
|
|
case 0:
|
|
break;
|
|
case 1: fvf|=D3DFVF_TEX1; break;
|
|
case 2: fvf|=D3DFVF_TEX2; break;
|
|
case 3: fvf|=D3DFVF_TEX3; break;
|
|
case 4: fvf|=D3DFVF_TEX4; break;
|
|
case 5: fvf|=D3DFVF_TEX5; break;
|
|
case 6: fvf|=D3DFVF_TEX6; break;
|
|
case 7: fvf|=D3DFVF_TEX7; break;
|
|
case 8: fvf|=D3DFVF_TEX8; break;
|
|
}
|
|
|
|
if (!mmc->Needs_Vertex_Normals()) { //enable_lighting || mmc->Get_Flag(MeshModelClass::PRELIT_MASK)) {
|
|
return fvf;
|
|
}
|
|
|
|
fvf|=D3DFVF_NORMAL; // Realtime-lit
|
|
return fvf;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8RigidFVFCategoryContainer::DX8RigidFVFCategoryContainer(unsigned FVF,bool sorting_)
|
|
:
|
|
DX8FVFCategoryContainer(FVF,sorting_),
|
|
vertex_buffer(0),
|
|
used_vertices(0),
|
|
delayed_matpass_head(NULL),
|
|
delayed_matpass_tail(NULL)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8RigidFVFCategoryContainer::~DX8RigidFVFCategoryContainer()
|
|
{
|
|
REF_PTR_RELEASE(vertex_buffer);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8RigidFVFCategoryContainer::Log(bool only_visible)
|
|
{
|
|
#ifdef ENABLE_CATEGORY_LOG
|
|
StringClass work(255,true);
|
|
work.Format("DX8RigidFVFCategoryContainer --------------\n");
|
|
WWDEBUG_SAY((work));
|
|
if (vertex_buffer) {
|
|
StringClass fvfname(255,true);
|
|
vertex_buffer->FVF_Info().Get_FVF_Name(fvfname);
|
|
work.Format("VB size (used/total): %d/%d FVF: %s\n",used_vertices,vertex_buffer->Get_Vertex_Count(),fvfname);
|
|
WWDEBUG_SAY((work));
|
|
}
|
|
else {
|
|
WWDEBUG_SAY(("EMPTY VB\n"));
|
|
}
|
|
if (index_buffer) {
|
|
work.Format("IB size (used/total): %d/%d\n",used_indices,index_buffer->Get_Index_Count());
|
|
WWDEBUG_SAY((work));
|
|
}
|
|
else {
|
|
WWDEBUG_SAY(("EMPTY IB\n"));
|
|
}
|
|
|
|
for (unsigned p=0;p<passes;++p) {
|
|
WWDEBUG_SAY(("Pass: %d\n",p));
|
|
|
|
TextureCategoryListIterator it(&texture_category_list[p]);
|
|
while (!it.Is_Done()) {
|
|
it.Peek_Obj()->Log(only_visible);
|
|
it.Next();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Generic render function for rigid meshes
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8RigidFVFCategoryContainer::Render(void)
|
|
{
|
|
if (!Anything_To_Render()) return;
|
|
AnythingToRender=false;
|
|
|
|
DX8Wrapper::Set_Vertex_Buffer(vertex_buffer);
|
|
|
|
DX8Wrapper::Set_Index_Buffer(index_buffer,0);
|
|
|
|
SNAPSHOT_SAY(("DX8RigidFVFCategoryContainer::Render()\n"));
|
|
int zbias=0;
|
|
DX8Wrapper::Set_DX8_ZBias(zbias);
|
|
for (unsigned p=0;p<passes;++p) {
|
|
SNAPSHOT_SAY(("Pass: %d\n",p));
|
|
while (DX8TextureCategoryClass * tex = visible_texture_category_list[p].Remove_Head()) {
|
|
tex->Render();
|
|
}
|
|
zbias++;
|
|
if (zbias>15) zbias=15;
|
|
DX8Wrapper::Set_DX8_ZBias(zbias);
|
|
}
|
|
|
|
Render_Procedural_Material_Passes();
|
|
|
|
DX8Wrapper::Set_DX8_ZBias(0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool DX8RigidFVFCategoryContainer::Check_If_Mesh_Fits(MeshModelClass* mmc)
|
|
{
|
|
if (!vertex_buffer) return true; // No VB created - mesh will fit as a new vb will be created when inserting
|
|
unsigned required_vertices=mmc->Get_Vertex_Count();
|
|
unsigned available_vertices=vertex_buffer->Get_Vertex_Count()-used_vertices;
|
|
unsigned required_polygons=mmc->Get_Polygon_Count();
|
|
if (mmc->Get_Gap_Filler()) {
|
|
required_polygons+=mmc->Get_Gap_Filler()->Get_Polygon_Count();
|
|
}
|
|
unsigned required_indices=required_polygons*3*mmc->Get_Pass_Count();
|
|
unsigned available_indices=index_buffer->Get_Index_Count()-used_indices;
|
|
if (
|
|
required_vertices<=available_vertices &&
|
|
(required_indices)<=available_indices) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class Vertex_Split_Table
|
|
{
|
|
MeshClass* mesh;
|
|
MeshModelClass* mmc;
|
|
bool npatch_enable;
|
|
unsigned polygon_count;
|
|
TriIndex* polygon_array;
|
|
|
|
bool allocated_polygon_array;
|
|
|
|
public:
|
|
Vertex_Split_Table(MeshClass* mesh_)
|
|
:
|
|
mesh(mesh_),
|
|
mmc(NULL),
|
|
npatch_enable(false),
|
|
allocated_polygon_array(false)
|
|
{
|
|
mmc = mesh_->Peek_Model();
|
|
if (DX8Wrapper::Get_Current_Caps()->Support_NPatches() && mmc->Needs_Vertex_Normals()) {
|
|
if (mmc->Get_Flag(MeshGeometryClass::ALLOW_NPATCHES)) {
|
|
npatch_enable=true;
|
|
}
|
|
}
|
|
|
|
const GapFillerClass* gap_filler=mmc->Get_Gap_Filler();
|
|
polygon_count=mmc->Get_Polygon_Count();
|
|
if (gap_filler) polygon_count+=gap_filler->Get_Polygon_Count();
|
|
// if (mmc->Get_Gap_Filler_Polygon_Count()) {
|
|
allocated_polygon_array=true;
|
|
polygon_array=new TriIndex[polygon_count];
|
|
memcpy(
|
|
polygon_array,
|
|
mmc->Get_Polygon_Array(),
|
|
mmc->Get_Polygon_Count()*sizeof(TriIndex));
|
|
if (gap_filler) {
|
|
memcpy(
|
|
polygon_array+mmc->Get_Polygon_Count(),
|
|
gap_filler->Get_Polygon_Array(),
|
|
gap_filler->Get_Polygon_Count()*sizeof(TriIndex));
|
|
}
|
|
// }
|
|
// else {
|
|
// polygon_array=const_cast<Vector3i*>(mmc->Get_Polygon_Array());
|
|
// }
|
|
|
|
}
|
|
|
|
~Vertex_Split_Table()
|
|
{
|
|
if (allocated_polygon_array) {
|
|
delete[] polygon_array;
|
|
}
|
|
}
|
|
|
|
const Vector3* Get_Vertex_Array() const
|
|
{
|
|
return mmc->Get_Vertex_Array();
|
|
}
|
|
|
|
const Vector3* Get_Vertex_Normal_Array() const
|
|
{
|
|
return mmc->Get_Vertex_Normal_Array();
|
|
}
|
|
|
|
const unsigned* Get_Color_Array(unsigned index) const
|
|
{
|
|
if ((index == 0) && (mesh->Get_User_Lighting_Array() != NULL)) {
|
|
return mesh->Get_User_Lighting_Array();
|
|
}
|
|
return mmc->Get_Color_Array(index,false);
|
|
}
|
|
|
|
const Vector2* Get_UV_Array(unsigned uv_array_index) const
|
|
{
|
|
return mmc->Get_UV_Array_By_Index(uv_array_index);
|
|
}
|
|
|
|
unsigned Get_Vertex_Count() const
|
|
{
|
|
return mmc->Get_Vertex_Count();
|
|
}
|
|
|
|
unsigned Get_Polygon_Count() const
|
|
{
|
|
return polygon_count;
|
|
}
|
|
|
|
unsigned Get_Pass_Count() const
|
|
{
|
|
return mmc->Get_Pass_Count();
|
|
}
|
|
|
|
TextureClass* Peek_Texture(unsigned idx,unsigned pass,unsigned stage)
|
|
{
|
|
if (mmc->Has_Texture_Array(pass,stage)) {
|
|
if (idx>=unsigned(mmc->Get_Polygon_Count())) {
|
|
WWASSERT(mmc->Get_Gap_Filler());
|
|
return mmc->Get_Gap_Filler()->Get_Texture_Array(pass,stage)[idx-mmc->Get_Polygon_Count()];
|
|
}
|
|
return mmc->Peek_Texture(idx,pass,stage);
|
|
}
|
|
return mmc->Peek_Single_Texture(pass,stage);
|
|
}
|
|
|
|
VertexMaterialClass* Peek_Material(unsigned idx,unsigned pass)
|
|
{
|
|
if (mmc->Has_Material_Array(pass)) {
|
|
if (idx>=unsigned(mmc->Get_Polygon_Count())) {
|
|
WWASSERT(mmc->Get_Gap_Filler());
|
|
return mmc->Get_Gap_Filler()->Get_Material_Array(pass)[idx-mmc->Get_Polygon_Count()];
|
|
}
|
|
return mmc->Peek_Material(mmc->Get_Polygon_Array()[idx][0],pass);
|
|
}
|
|
return mmc->Peek_Single_Material(pass);
|
|
}
|
|
|
|
ShaderClass Peek_Shader(unsigned idx,unsigned pass)
|
|
{
|
|
if (mmc->Has_Shader_Array(pass)) {
|
|
ShaderClass shader;
|
|
|
|
if (idx>=unsigned(mmc->Get_Polygon_Count())) {
|
|
WWASSERT(mmc->Get_Gap_Filler());
|
|
shader=mmc->Get_Gap_Filler()->Get_Shader_Array(pass)[idx-mmc->Get_Polygon_Count()];
|
|
}
|
|
else shader=mmc->Get_Shader(idx,pass);
|
|
|
|
if (npatch_enable) {
|
|
shader.Set_NPatch_Enable(ShaderClass::NPATCH_ENABLE);
|
|
}
|
|
|
|
return shader;
|
|
}
|
|
if (!npatch_enable) return mmc->Get_Single_Shader(pass);
|
|
ShaderClass shader=mmc->Get_Single_Shader(pass);
|
|
shader.Set_NPatch_Enable(ShaderClass::NPATCH_ENABLE);
|
|
return shader;
|
|
|
|
}
|
|
|
|
MeshModelClass* Get_Mesh_Model_Class()
|
|
{
|
|
return mmc;
|
|
}
|
|
|
|
MeshClass * Get_Mesh_Class()
|
|
{
|
|
return mesh;
|
|
}
|
|
|
|
unsigned short* Get_Polygon_Array(unsigned pass)
|
|
{
|
|
return (unsigned short*)polygon_array;
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8RigidFVFCategoryContainer::Add_Mesh(MeshClass* mesh_)
|
|
{
|
|
MeshModelClass * mmc_ = mesh_->Peek_Model();
|
|
WWASSERT(Check_If_Mesh_Fits(mmc_));
|
|
|
|
Vertex_Split_Table split_table(mesh_);
|
|
int needed_vertices=split_table.Get_Vertex_Count();
|
|
|
|
/*
|
|
** This FVFCategoryContainer doesn't have a vertex buffer yet so allocate one big
|
|
** enough to contain this mesh.
|
|
*/
|
|
if (!vertex_buffer) {
|
|
int vb_size=4000;
|
|
if (vb_size<needed_vertices) vb_size=needed_vertices;
|
|
if (sorting) {
|
|
vertex_buffer=NEW_REF(SortingVertexBufferClass,(vb_size));
|
|
WWASSERT(vertex_buffer->FVF_Info().Get_FVF()==FVF); // Only one sorting FVF type!
|
|
}
|
|
else {
|
|
vertex_buffer=NEW_REF(DX8VertexBufferClass,(
|
|
FVF,
|
|
vb_size,
|
|
(DX8Wrapper::Get_Current_Caps()->Support_NPatches() && WW3D::Get_NPatches_Level()>1) ? DX8VertexBufferClass::USAGE_NPATCHES : DX8VertexBufferClass::USAGE_DEFAULT));
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Append this mesh's vertices to the vertex buffer.
|
|
*/
|
|
|
|
VertexBufferClass::AppendLockClass l(vertex_buffer,used_vertices,split_table.Get_Vertex_Count());
|
|
const FVFInfoClass fi=vertex_buffer->FVF_Info();
|
|
unsigned char *vb=(unsigned char*) l.Get_Vertex_Array();
|
|
unsigned int i;
|
|
const Vector3 *locs=split_table.Get_Vertex_Array();
|
|
const Vector3 *norms=split_table.Get_Vertex_Normal_Array();
|
|
const unsigned *diffuse=split_table.Get_Color_Array(0);
|
|
const unsigned *specular=split_table.Get_Color_Array(1);
|
|
for (i=0; i<split_table.Get_Vertex_Count(); i++)
|
|
{
|
|
*(Vector3*)(vb+fi.Get_Location_Offset())=locs[i];
|
|
|
|
if ((FVF&D3DFVF_NORMAL)==D3DFVF_NORMAL && norms) {
|
|
*(Vector3*)(vb+fi.Get_Normal_Offset())=norms[i];
|
|
}
|
|
|
|
if ((FVF&D3DFVF_DIFFUSE)==D3DFVF_DIFFUSE) {
|
|
if (diffuse) {
|
|
*(unsigned int*)(vb+fi.Get_Diffuse_Offset())=diffuse[i];
|
|
} else {
|
|
*(unsigned int*)(vb+fi.Get_Diffuse_Offset()) = 0xFFFFFFFF;
|
|
}
|
|
}
|
|
|
|
if ((FVF&D3DFVF_SPECULAR)==D3DFVF_SPECULAR) {
|
|
if (specular) {
|
|
*(unsigned int*)(vb+fi.Get_Specular_Offset())=specular[i];
|
|
} else {
|
|
*(unsigned int*)(vb+fi.Get_Specular_Offset()) = 0xFFFFFFFF;
|
|
}
|
|
}
|
|
|
|
vb+=fi.Get_FVF_Size();
|
|
}
|
|
|
|
|
|
/*
|
|
** Append the UV coordinates to the vertex buffer
|
|
*/
|
|
int uvcount = 0;
|
|
if ((FVF&D3DFVF_TEX1) == D3DFVF_TEX1) {
|
|
uvcount = 1;
|
|
}
|
|
if ((FVF&D3DFVF_TEX2) == D3DFVF_TEX2) {
|
|
uvcount = 2;
|
|
}
|
|
if ((FVF&D3DFVF_TEX3) == D3DFVF_TEX3) {
|
|
uvcount = 3;
|
|
}
|
|
if ((FVF&D3DFVF_TEX4) == D3DFVF_TEX4) {
|
|
uvcount = 4;
|
|
}
|
|
if ((FVF&D3DFVF_TEX5) == D3DFVF_TEX5) {
|
|
uvcount = 5;
|
|
}
|
|
if ((FVF&D3DFVF_TEX6) == D3DFVF_TEX6) {
|
|
uvcount = 6;
|
|
}
|
|
if ((FVF&D3DFVF_TEX7) == D3DFVF_TEX7) {
|
|
uvcount = 7;
|
|
}
|
|
if ((FVF&D3DFVF_TEX8) == D3DFVF_TEX8) {
|
|
uvcount = 8;
|
|
}
|
|
|
|
for (int j=0; j<uvcount; j++) {
|
|
unsigned char *vb=(unsigned char*) l.Get_Vertex_Array();
|
|
const Vector2*uvs=split_table.Get_UV_Array(j);
|
|
if (uvs) {
|
|
for (i=0; i<split_table.Get_Vertex_Count(); i++)
|
|
{
|
|
*(Vector2*)(vb+fi.Get_Tex_Offset(j))=uvs[i];
|
|
vb+=fi.Get_FVF_Size();
|
|
}
|
|
}
|
|
}
|
|
|
|
Generate_Texture_Categories(split_table,used_vertices);
|
|
|
|
used_vertices+=needed_vertices;//vertex_count;
|
|
}
|
|
|
|
void DX8FVFCategoryContainer::Insert_To_Texture_Category(
|
|
Vertex_Split_Table& split_table,
|
|
TextureClass** texs,
|
|
VertexMaterialClass* mat,
|
|
ShaderClass shader,
|
|
int pass,
|
|
unsigned vertex_offset)
|
|
{
|
|
/*
|
|
** Try to find a DX8TextureCategoryClass in this FVF container which matches the
|
|
** given textures(one per stage), material and shader combination.
|
|
*/
|
|
bool fit_in_existing_category = false;
|
|
TextureCategoryListIterator it(&texture_category_list[pass]);
|
|
while (!it.Is_Done()) {
|
|
DX8TextureCategoryClass * tex_category=it.Peek_Obj();
|
|
// Compare all stage's textures
|
|
bool all_textures_same = true;
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
all_textures_same = all_textures_same && (tex_category->Peek_Texture(stage) == texs[stage]);
|
|
}
|
|
if (all_textures_same && Equal_Material(tex_category->Peek_Material(),mat) && tex_category->Get_Shader()==shader) {
|
|
used_indices+=tex_category->Add_Mesh(split_table,vertex_offset,used_indices,index_buffer,pass);
|
|
fit_in_existing_category = true;
|
|
break;
|
|
}
|
|
it.Next();
|
|
}
|
|
|
|
if (!fit_in_existing_category) {
|
|
|
|
DX8TextureCategoryClass * new_tex_category=new DX8TextureCategoryClass(this,texs,shader,mat,pass);
|
|
used_indices+=new_tex_category->Add_Mesh(split_table,vertex_offset,used_indices,index_buffer,pass);
|
|
|
|
/*
|
|
** Add the texture category object into the list, immediately after any existing
|
|
** texture category object which uses the same texture. This will result in
|
|
** the list always having matching texture categories next to each other.
|
|
*/
|
|
bool found_similar_category = false;
|
|
TextureCategoryListIterator it(&texture_category_list[pass]);
|
|
while (!it.Is_Done()) {
|
|
// Categorize according to first stage's texture for now
|
|
if (it.Peek_Obj()->Peek_Texture(0) == texs[0]) {
|
|
texture_category_list[pass].Add_After(new_tex_category,it.Peek_Obj());
|
|
found_similar_category = true;
|
|
break;
|
|
}
|
|
it.Next();
|
|
}
|
|
|
|
if (!found_similar_category) {
|
|
texture_category_list[pass].Add_Tail(new_tex_category);
|
|
}
|
|
}
|
|
}
|
|
|
|
const unsigned MAX_ADDED_TYPE_COUNT=64;
|
|
struct Textures_Material_And_Shader_Booking_Struct
|
|
{
|
|
TextureClass* added_textures[MeshMatDescClass::MAX_TEX_STAGES][MAX_ADDED_TYPE_COUNT];
|
|
VertexMaterialClass* added_materials[MAX_ADDED_TYPE_COUNT];
|
|
ShaderClass added_shaders[MAX_ADDED_TYPE_COUNT];
|
|
unsigned added_type_count;
|
|
|
|
Textures_Material_And_Shader_Booking_Struct() : added_type_count(0) {}
|
|
|
|
bool Add_Textures_Material_And_Shader(TextureClass** texs, VertexMaterialClass* mat, ShaderClass shd)
|
|
{
|
|
for (unsigned a=0;a<added_type_count;++a) {
|
|
// Compare textures
|
|
bool all_textures_same = true;
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
all_textures_same = all_textures_same && (texs[stage] == added_textures[stage][a]);
|
|
}
|
|
if (all_textures_same && Equal_Material(mat,added_materials[a]) && shd==added_shaders[a]) {
|
|
return false;
|
|
}
|
|
}
|
|
WWASSERT(added_type_count<MAX_ADDED_TYPE_COUNT);
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
added_textures[stage][added_type_count]=texs[stage];
|
|
}
|
|
added_materials[added_type_count]=mat;
|
|
added_shaders[added_type_count]=shd;
|
|
added_type_count++;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
void DX8FVFCategoryContainer::Generate_Texture_Categories(Vertex_Split_Table& split_table,unsigned vertex_offset)
|
|
{
|
|
int polygon_count=split_table.Get_Polygon_Count();
|
|
int index_count=polygon_count*3*split_table.Get_Pass_Count();
|
|
|
|
/*
|
|
** If we don't have an index buffer yet, allocate one. Make it hold at least 12000 entries,
|
|
** more if the mesh requires it.
|
|
*/
|
|
if (!index_buffer) {
|
|
int ib_size=12000;
|
|
if (ib_size<index_count) ib_size=index_count;
|
|
if (sorting) {
|
|
index_buffer=NEW_REF(SortingIndexBufferClass,(ib_size));
|
|
}
|
|
else {
|
|
index_buffer=NEW_REF(DX8IndexBufferClass,(
|
|
ib_size,
|
|
(DX8Wrapper::Get_Current_Caps()->Support_NPatches() && WW3D::Get_NPatches_Level()>1) ? DX8IndexBufferClass::USAGE_NPATCHES : DX8IndexBufferClass::USAGE_DEFAULT));
|
|
}
|
|
}
|
|
|
|
for (unsigned pass=0;pass<split_table.Get_Pass_Count();++pass) {
|
|
Textures_Material_And_Shader_Booking_Struct textures_material_and_shader_booking;
|
|
|
|
unsigned old_used_indices=used_indices;
|
|
|
|
for (int i=0;i<polygon_count;++i) {
|
|
TextureClass* textures[MeshMatDescClass::MAX_TEX_STAGES];
|
|
WWASSERT(MAX_TEXTURE_STAGES==MeshMatDescClass::MAX_TEX_STAGES);
|
|
for (int stage=0;stage<MeshMatDescClass::MAX_TEX_STAGES;stage++) {
|
|
textures[stage]=split_table.Peek_Texture(i,pass,stage);
|
|
}
|
|
VertexMaterialClass* mat=split_table.Peek_Material(i,pass);
|
|
ShaderClass shader=split_table.Peek_Shader(i,pass);
|
|
if (!textures_material_and_shader_booking.Add_Textures_Material_And_Shader(textures,mat,shader)) continue;
|
|
|
|
Insert_To_Texture_Category(split_table,textures,mat,shader,pass,vertex_offset);
|
|
}
|
|
|
|
int new_inds=used_indices-old_used_indices;
|
|
WWASSERT(new_inds<=polygon_count*3);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8SkinFVFCategoryContainer::DX8SkinFVFCategoryContainer(bool sorting)
|
|
:
|
|
DX8FVFCategoryContainer(DX8_FVF_XYZNUV1,sorting),
|
|
VisibleVertexCount(0),
|
|
VisibleSkinHead(NULL)
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
DX8SkinFVFCategoryContainer::~DX8SkinFVFCategoryContainer()
|
|
{
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8SkinFVFCategoryContainer::Log(bool only_visible)
|
|
{
|
|
#ifdef ENABLE_CATEGORY_LOG
|
|
StringClass work(255,true);
|
|
work.Format("DX8SkinFVFCategoryContainer --------------\n");
|
|
WWDEBUG_SAY((work));
|
|
|
|
if (index_buffer) {
|
|
work.Format("IB size (used/total): %d/%d\n",used_indices,index_buffer->Get_Index_Count());
|
|
WWDEBUG_SAY((work));
|
|
}
|
|
else {
|
|
WWDEBUG_SAY(("EMPTY IB\n"));
|
|
}
|
|
|
|
for (unsigned pass=0;pass<passes;++pass) {
|
|
TextureCategoryListIterator it(&texture_category_list[pass]);
|
|
while (!it.Is_Done()) {
|
|
it.Peek_Obj()->Log(only_visible);
|
|
it.Next();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8SkinFVFCategoryContainer::Render(void)
|
|
{
|
|
SNAPSHOT_SAY(("DX8SkinFVFCategoryContainer::Render()\n"));
|
|
if (!Anything_To_Render()) {
|
|
SNAPSHOT_SAY(("Nothing to render\n"));
|
|
return;
|
|
}
|
|
AnythingToRender=false;
|
|
|
|
DX8Wrapper::Set_Vertex_Buffer(NULL); // Free up the reference to the current vertex buffer
|
|
// (in case it is the dynamic, which may have to be resized)
|
|
|
|
DynamicVBAccessClass vb(
|
|
sorting ? BUFFER_TYPE_DYNAMIC_SORTING : BUFFER_TYPE_DYNAMIC_DX8,
|
|
dynamic_fvf_type,
|
|
VisibleVertexCount);
|
|
SNAPSHOT_SAY(("DynamicVBAccess - %s - %d vertices\n",sorting ? "sorting" : "non-sorting",VisibleVertexCount));
|
|
|
|
unsigned vertex_offset=0;
|
|
|
|
{
|
|
DynamicVBAccessClass::WriteLockClass l(&vb);
|
|
VertexFormatXYZNDUV2 * dest_verts = l.Get_Formatted_Vertex_Array();
|
|
|
|
MeshClass * mesh = VisibleSkinHead;
|
|
while (mesh != NULL) {
|
|
|
|
MeshModelClass * mmc = mesh->Peek_Model();
|
|
int mesh_vertex_count=mmc->Get_Vertex_Count();
|
|
|
|
WWASSERT((vertex_offset+mesh_vertex_count)<=VisibleVertexCount);
|
|
|
|
DX8_RECORD_SKIN_RENDER(mesh->Get_Num_Polys(),mesh_vertex_count);
|
|
|
|
if (_TempVertexBuffer.Length() < mesh_vertex_count) _TempVertexBuffer.Resize(mesh_vertex_count);
|
|
if (_TempNormalBuffer.Length() < mesh_vertex_count) _TempNormalBuffer.Resize(mesh_vertex_count);
|
|
|
|
Vector3* loc=&(_TempVertexBuffer[0]);
|
|
Vector3* norm=&(_TempNormalBuffer[0]);
|
|
const Vector2* uv0=mmc->Get_UV_Array_By_Index(0);
|
|
const Vector2* uv1=mmc->Get_UV_Array_By_Index(1);
|
|
const unsigned* diffuse=mmc->Get_Color_Array(0,false);
|
|
|
|
VertexFormatXYZNDUV2* verts=dest_verts+vertex_offset;
|
|
|
|
// mesh->Compose_Deformed_Vertex_Buffer(verts,uv0,uv1,diffuse);
|
|
mesh->Get_Deformed_Vertices(loc,norm);
|
|
|
|
for (int v=0;v<mesh_vertex_count;++v) {
|
|
verts[v].x=(*loc)[0];
|
|
verts[v].y=(*loc)[1];
|
|
verts[v].z=(*loc)[2];
|
|
verts[v].nx=(*norm)[0];
|
|
verts[v].ny=(*norm)[1];
|
|
verts[v].nz=(*norm)[2];
|
|
if (diffuse) {
|
|
verts[v].diffuse=*diffuse++;
|
|
}
|
|
else {
|
|
verts[v].diffuse=0;
|
|
}
|
|
if (uv0) {
|
|
verts[v].u1=(*uv0)[0];
|
|
verts[v].v1=(*uv0)[1];
|
|
uv0++;
|
|
}
|
|
else {
|
|
verts[v].u1=0.0f;
|
|
verts[v].v1=0.0f;
|
|
}
|
|
if (uv1) {
|
|
verts[v].u2=(*uv1)[0];
|
|
verts[v].v2=(*uv1)[1];
|
|
uv1++;
|
|
}
|
|
else {
|
|
verts[v].u2=0.0f;
|
|
verts[v].v2=0.0f;
|
|
}
|
|
|
|
loc++;
|
|
norm++;
|
|
}
|
|
|
|
|
|
mesh->Set_Base_Vertex_Offset(vertex_offset);
|
|
vertex_offset+=mesh_vertex_count;
|
|
|
|
mesh = mesh->Peek_Next_Visible_Skin();
|
|
}
|
|
}
|
|
WWASSERT(vertex_offset==VisibleVertexCount);
|
|
|
|
SNAPSHOT_SAY(("Set vb: %x ib: %x\n",vb,index_buffer));
|
|
|
|
DX8Wrapper::Set_Vertex_Buffer(vb);
|
|
DX8Wrapper::Set_Index_Buffer(index_buffer,0);
|
|
|
|
for (unsigned pass=0;pass<passes;++pass) {
|
|
SNAPSHOT_SAY(("Pass: %d\n",pass));
|
|
while (DX8TextureCategoryClass * tex = visible_texture_category_list[pass].Remove_Head()) {
|
|
tex->Render();
|
|
}
|
|
}
|
|
|
|
Render_Procedural_Material_Passes();
|
|
|
|
VisibleSkinHead = NULL;
|
|
VisibleVertexCount = 0;
|
|
}
|
|
|
|
bool DX8SkinFVFCategoryContainer::Check_If_Mesh_Fits(MeshModelClass* mmc)
|
|
{
|
|
if (!index_buffer) return true; // No IB created - mesh will fit as a new ib will be created when inserting
|
|
int required_polygons=mmc->Get_Polygon_Count();
|
|
if (mmc->Get_Gap_Filler()) {
|
|
required_polygons+=mmc->Get_Gap_Filler()->Get_Polygon_Count();
|
|
}
|
|
|
|
if ((required_polygons*3*mmc->Get_Pass_Count())<=index_buffer->Get_Index_Count()-used_indices) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void DX8SkinFVFCategoryContainer::Add_Visible_Skin(MeshClass * mesh)
|
|
{
|
|
mesh->Set_Next_Visible_Skin(VisibleSkinHead);
|
|
VisibleSkinHead = mesh;
|
|
VisibleVertexCount += mesh->Peek_Model()->Get_Vertex_Count();
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8SkinFVFCategoryContainer::Reset()
|
|
{
|
|
VisibleVertexCount = 0;
|
|
VisibleSkinHead = NULL;
|
|
|
|
for (unsigned pass=0;pass<passes;++pass) {
|
|
while (DX8TextureCategoryClass* texture_category=texture_category_list[pass].Peek_Head()) {
|
|
delete texture_category;
|
|
}
|
|
}
|
|
|
|
REF_PTR_RELEASE(index_buffer);
|
|
used_indices=0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8SkinFVFCategoryContainer::Add_Mesh(MeshClass* mesh)
|
|
{
|
|
Vertex_Split_Table split_table(mesh);
|
|
|
|
Generate_Texture_Categories(split_table,0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
unsigned DX8TextureCategoryClass::Add_Mesh(
|
|
Vertex_Split_Table& split_table,
|
|
unsigned vertex_offset,
|
|
unsigned index_offset,
|
|
IndexBufferClass* index_buffer,
|
|
unsigned pass)
|
|
{
|
|
int poly_count=split_table.Get_Polygon_Count();
|
|
|
|
unsigned index_count=0;
|
|
|
|
/*
|
|
** Count the polygons in the given mesh in the given pass which match this texture category
|
|
*/
|
|
unsigned polygons=0;
|
|
|
|
for (int i=0;i<poly_count;++i) {
|
|
bool all_textures_same = true;
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
all_textures_same = all_textures_same && (split_table.Peek_Texture(i, pass, stage) == textures[stage]);
|
|
}
|
|
VertexMaterialClass* mat=split_table.Peek_Material(i,pass);
|
|
ShaderClass shd=split_table.Peek_Shader(i,pass);
|
|
|
|
if (all_textures_same && Equal_Material(mat,material) && shd==shader) {
|
|
polygons++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Add the indices for the polygons that match into this renderer's dx8 index table.
|
|
*/
|
|
if (polygons) {
|
|
|
|
index_count=polygons*3;
|
|
#ifndef ENABLE_STRIPING
|
|
bool stripify=false;
|
|
#else
|
|
bool stripify=true;
|
|
if (index_buffer->Type()==BUFFER_TYPE_SORTING || index_buffer->Type()==BUFFER_TYPE_DYNAMIC_SORTING) {
|
|
stripify=false;
|
|
}
|
|
#endif;
|
|
const TriIndex* src_indices=(const TriIndex*)split_table.Get_Polygon_Array(pass);//mmc->Get_Polygon_Array();
|
|
|
|
if (stripify) {
|
|
int* triangles=new int[index_count];
|
|
int triangle_index_count=0;
|
|
for (int i=0;i<poly_count;++i) {
|
|
bool all_textures_same = true;
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
all_textures_same = all_textures_same && (split_table.Peek_Texture(i, pass, stage) == textures[stage]);
|
|
}
|
|
VertexMaterialClass* mat=split_table.Peek_Material(i,pass);
|
|
ShaderClass shd=split_table.Peek_Shader(i,pass);
|
|
|
|
if (all_textures_same && Equal_Material(mat,material) && shd==shader) {
|
|
triangles[triangle_index_count++]=src_indices[i][0]+vertex_offset;
|
|
triangles[triangle_index_count++]=src_indices[i][1]+vertex_offset;
|
|
triangles[triangle_index_count++]=src_indices[i][2]+vertex_offset;
|
|
}
|
|
}
|
|
|
|
int* strips=StripOptimizerClass::Stripify(triangles, triangle_index_count/3);
|
|
delete[] triangles;
|
|
int* strip=StripOptimizerClass::Combine_Strips(strips+1,strips[0]);
|
|
delete[] strips;
|
|
|
|
if (index_count<unsigned(strip[0])) {
|
|
stripify=false;
|
|
}
|
|
else {
|
|
index_count=strip[0];
|
|
|
|
DX8PolygonRendererClass* p_renderer=new DX8PolygonRendererClass(
|
|
index_count,
|
|
split_table.Get_Mesh_Class(),
|
|
this,
|
|
vertex_offset,
|
|
index_offset,
|
|
true);
|
|
PolygonRendererList.Add_Tail(p_renderer);
|
|
|
|
{
|
|
IndexBufferClass::AppendLockClass l(index_buffer,index_offset,index_count);
|
|
unsigned short* dst_indices=l.Get_Index_Array();
|
|
|
|
unsigned short vmin=0xffff;
|
|
unsigned short vmax=0;
|
|
|
|
/*
|
|
** Iterate over the polys for this pass, adding each one that matches this texture+material+shader
|
|
*/
|
|
for (unsigned i=0;i<index_count;++i) {
|
|
unsigned short idx;
|
|
|
|
idx=unsigned short(strip[i+1]);
|
|
vmin=MIN(vmin,idx);
|
|
vmax=MAX(vmax,idx);
|
|
*dst_indices++=idx;
|
|
}
|
|
|
|
/*
|
|
** Remember the min and max vertex indices that these polygons used (for optimization)
|
|
*/
|
|
p_renderer->Set_Vertex_Index_Range(vmin,vmax-vmin+1);
|
|
}
|
|
}
|
|
delete[] strip;
|
|
}
|
|
|
|
// Need to check stripify again as it may be changed to false by the previous statement
|
|
if (!stripify ) {
|
|
DX8PolygonRendererClass* p_renderer=new DX8PolygonRendererClass(
|
|
index_count,
|
|
split_table.Get_Mesh_Class(),
|
|
this,
|
|
vertex_offset,
|
|
index_offset,
|
|
false);
|
|
PolygonRendererList.Add_Tail(p_renderer);
|
|
|
|
IndexBufferClass::AppendLockClass l(index_buffer,index_offset,index_count);
|
|
unsigned short* dst_indices=l.Get_Index_Array();
|
|
|
|
unsigned short vmin=0xffff;
|
|
unsigned short vmax=0;
|
|
|
|
/*
|
|
** Iterate over the polys for this pass, adding each one that matches this texture+material+shader
|
|
*/
|
|
for (int i=0;i<poly_count;++i) {
|
|
bool all_textures_same = true;
|
|
for (unsigned int stage = 0; stage < MeshMatDescClass::MAX_TEX_STAGES; stage++) {
|
|
all_textures_same = all_textures_same && (split_table.Peek_Texture(i, pass, stage) == textures[stage]);
|
|
}
|
|
VertexMaterialClass* mat=split_table.Peek_Material(i,pass);
|
|
ShaderClass shd=split_table.Peek_Shader(i,pass);
|
|
|
|
if (all_textures_same && Equal_Material(mat,material) && shd==shader) {
|
|
unsigned short idx;
|
|
|
|
idx=unsigned short(src_indices[i][0]+vertex_offset);
|
|
vmin=MIN(vmin,idx);
|
|
vmax=MAX(vmax,idx);
|
|
*dst_indices++=idx;
|
|
// WWDEBUG_SAY(("%d, ",idx));
|
|
|
|
idx=unsigned short(src_indices[i][1]+vertex_offset);
|
|
vmin=MIN(vmin,idx);
|
|
vmax=MAX(vmax,idx);
|
|
*dst_indices++=idx;
|
|
// WWDEBUG_SAY(("%d, ",idx));
|
|
|
|
idx=unsigned short(src_indices[i][2]+vertex_offset);
|
|
vmin=MIN(vmin,idx);
|
|
vmax=MAX(vmax,idx);
|
|
*dst_indices++=idx;
|
|
// WWDEBUG_SAY(("%d\n",idx));
|
|
}
|
|
}
|
|
|
|
WWASSERT((vmax-vmin)<split_table.Get_Mesh_Model_Class()->Get_Vertex_Count());
|
|
|
|
/*
|
|
** Remember the min and max vertex indices that these polygons used (for optimization)
|
|
*/
|
|
p_renderer->Set_Vertex_Index_Range(vmin,vmax-vmin+1);
|
|
WWASSERT(index_count<=unsigned(split_table.Get_Polygon_Count()*3));
|
|
}
|
|
}
|
|
|
|
return index_count;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8TextureCategoryClass::Render(void)
|
|
{
|
|
#ifdef WWDEBUG
|
|
if (!WW3D::Expose_Prelit()) {
|
|
#endif
|
|
|
|
for (unsigned i=0;i<MAX_TEXTURE_STAGES;++i) {
|
|
SNAPSHOT_SAY(("Set_Texture(%d,%s)\n",i,Peek_Texture(i) ? Peek_Texture(i)->Get_Texture_Name() : "NULL"));
|
|
DX8Wrapper::Set_Texture(i,Peek_Texture(i));
|
|
}
|
|
|
|
#ifdef WWDEBUG
|
|
}
|
|
#endif
|
|
|
|
SNAPSHOT_SAY(("Set_Material(%s)\n",Peek_Material() ? Peek_Material()->Get_Name() : "NULL"));
|
|
DX8Wrapper::Set_Material(Peek_Material());
|
|
|
|
SNAPSHOT_SAY(("Set_Shader(0x%x)\n",Get_Shader()));
|
|
DX8Wrapper::Set_Shader(Get_Shader());
|
|
|
|
PolyRenderTaskClass * prt = render_task_head;
|
|
while (prt) {
|
|
|
|
/*
|
|
** Dig out the parameters for this render task
|
|
*/
|
|
DX8PolygonRendererClass * renderer = prt->Peek_Polygon_Renderer();
|
|
MeshClass * mesh = prt->Peek_Mesh();
|
|
|
|
SNAPSHOT_SAY(("mesh = %s\n",mesh->Get_Name()));
|
|
|
|
#ifdef WWDEBUG
|
|
// Debug rendering: if it exists, expose prelighting on this mesh by disabling all base textures.
|
|
if (WW3D::Expose_Prelit()) {
|
|
switch (mesh->Peek_Model()->Get_Flag (MeshGeometryClass::PRELIT_MASK)) {
|
|
|
|
unsigned i;
|
|
|
|
case MeshGeometryClass::PRELIT_VERTEX:
|
|
|
|
// Disable texturing on all stages and passes.
|
|
for (i = 0; i < MAX_TEXTURE_STAGES; i++) {
|
|
DX8Wrapper::Set_Texture (i, NULL);
|
|
}
|
|
break;
|
|
|
|
case MeshGeometryClass::PRELIT_LIGHTMAP_MULTI_PASS:
|
|
|
|
// Disable texturing on all but the last pass.
|
|
if (pass == mesh->Peek_Model()->Get_Pass_Count() - 1) {
|
|
for (i = 0; i < MAX_TEXTURE_STAGES; i++) {
|
|
DX8Wrapper::Set_Texture (i, Peek_Texture (i));
|
|
}
|
|
} else {
|
|
for (i = 0; i < MAX_TEXTURE_STAGES; i++) {
|
|
DX8Wrapper::Set_Texture (i, NULL);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MeshGeometryClass::PRELIT_LIGHTMAP_MULTI_TEXTURE:
|
|
|
|
// Disable texturing on all but the zeroth stage of each pass.
|
|
DX8Wrapper::Set_Texture (0, Peek_Texture (0));
|
|
for (i = 1; i < MAX_TEXTURE_STAGES; i++) {
|
|
DX8Wrapper::Set_Texture (i, NULL);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
for (i = 0; i < MAX_TEXTURE_STAGES; i++) {
|
|
DX8Wrapper::Set_Texture (i, Peek_Texture (i));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** If the user is not installing LightEnvironmentClasses, we leave the lighting render
|
|
** states untouched. This way they can set a couple global lights that affect the entire scene.
|
|
*/
|
|
LightEnvironmentClass * lenv = mesh->Get_Lighting_Environment();
|
|
if (lenv != NULL) {
|
|
SNAPSHOT_SAY(("LightEnvironment, lights: %d\n",lenv->Get_Light_Count()));
|
|
DX8Wrapper::Set_Light_Environment(lenv);
|
|
}
|
|
else {
|
|
SNAPSHOT_SAY(("No light environment\n"));
|
|
}
|
|
|
|
/*
|
|
** Support for ALIGNED and ORIENTED camera modes
|
|
*/
|
|
const Matrix3D* world_transform = &mesh->Get_Transform();
|
|
bool identity=mesh->Is_Transform_Identity();
|
|
Matrix3D tmp_world;
|
|
|
|
if (mesh->Peek_Model()->Get_Flag(MeshModelClass::ALIGNED)) {
|
|
SNAPSHOT_SAY(("Camera mode ALIGNED\n"));
|
|
|
|
Vector3 mesh_position;
|
|
Vector3 camera_z_vector;
|
|
|
|
TheDX8MeshRenderer.Peek_Camera()->Get_Transform().Get_Z_Vector(&camera_z_vector);
|
|
mesh->Get_Transform().Get_Translation(&mesh_position);
|
|
|
|
tmp_world.Obj_Look_At(mesh_position,mesh_position + camera_z_vector,0.0f);
|
|
world_transform = &tmp_world;
|
|
|
|
} else if (mesh->Peek_Model()->Get_Flag(MeshModelClass::ORIENTED)) {
|
|
SNAPSHOT_SAY(("Camera mode ORIENTED\n"));
|
|
|
|
Vector3 mesh_position;
|
|
Vector3 camera_position;
|
|
|
|
TheDX8MeshRenderer.Peek_Camera()->Get_Transform().Get_Translation(&camera_position);
|
|
mesh->Get_Transform().Get_Translation(&mesh_position);
|
|
|
|
tmp_world.Obj_Look_At(mesh_position,camera_position,0.0f);
|
|
world_transform = &tmp_world;
|
|
|
|
} else if (mesh->Peek_Model()->Get_Flag(MeshModelClass::SKIN)) {
|
|
SNAPSHOT_SAY(("Set world identity (for skin)\n"));
|
|
|
|
tmp_world.Make_Identity();
|
|
world_transform = &tmp_world;
|
|
identity=true;
|
|
}
|
|
|
|
|
|
if (identity) {
|
|
SNAPSHOT_SAY(("Set_World_Identity\n"));
|
|
DX8Wrapper::Set_World_Identity();
|
|
}
|
|
else {
|
|
SNAPSHOT_SAY(("Set_World_Transform\n"));
|
|
DX8Wrapper::Set_Transform(D3DTS_WORLD,*world_transform);
|
|
}
|
|
|
|
// The mesh renderer debugger can disable mesh rendering
|
|
if (!DX8RendererDebugger::Is_Enabled() || !mesh->Is_Disabled_By_Debugger()) {
|
|
/*
|
|
** Render mesh using either sorting or immediate pipeline
|
|
*/
|
|
if ((!!mesh->Peek_Model()->Get_Flag(MeshGeometryClass::SORT)) && WW3D::Is_Sorting_Enabled()) {
|
|
renderer->Render_Sorted(mesh->Get_Base_Vertex_Offset(),mesh->Get_Bounding_Sphere());
|
|
} else {
|
|
renderer->Render(mesh->Get_Base_Vertex_Offset());
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Move to the next render task. Note that the delete should be fast because prt's are pooled
|
|
*/
|
|
PolyRenderTaskClass * next_prt = prt->Get_Next_Visible();
|
|
delete prt;
|
|
prt = next_prt;
|
|
}
|
|
|
|
Clear_Render_List();
|
|
}
|
|
|
|
|
|
DX8MeshRendererClass::DX8MeshRendererClass()
|
|
:
|
|
camera(NULL),
|
|
enable_lighting(true),
|
|
texture_category_container_list_skin(NULL),
|
|
visible_decal_meshes(NULL)
|
|
{
|
|
}
|
|
|
|
DX8MeshRendererClass::~DX8MeshRendererClass()
|
|
{
|
|
Invalidate();
|
|
Clear_Pending_Delete_Lists();
|
|
if (texture_category_container_list_skin != NULL) {
|
|
delete texture_category_container_list_skin;
|
|
}
|
|
}
|
|
|
|
void DX8MeshRendererClass::Init(void)
|
|
{
|
|
texture_category_container_list_skin = new FVFCategoryList;
|
|
}
|
|
|
|
void DX8MeshRendererClass::Shutdown(void)
|
|
{
|
|
Invalidate();
|
|
Clear_Pending_Delete_Lists();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8MeshRendererClass::Clear_Pending_Delete_Lists()
|
|
{
|
|
while (DX8TextureCategoryClass* category=texture_category_delete_list.Remove_Head()) {
|
|
delete category;
|
|
}
|
|
while (DX8FVFCategoryContainer* container=fvf_category_container_delete_list.Remove_Head()) {
|
|
delete container;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void Add_Rigid_Mesh_To_Container(FVFCategoryList* container_list,unsigned fvf,MeshClass* mesh)
|
|
{
|
|
WWASSERT(container_list);
|
|
DX8FVFCategoryContainer * container = NULL;
|
|
MeshModelClass * mmc = mesh->Peek_Model();
|
|
bool sorting=((!!mmc->Get_Flag(MeshModelClass::SORT)) && WW3D::Is_Sorting_Enabled() && (mmc->Get_Sort_Level() == SORT_LEVEL_NONE));
|
|
|
|
FVFCategoryListIterator it(container_list);
|
|
while (!it.Is_Done()) {
|
|
container = it.Peek_Obj();
|
|
if (sorting==container->Is_Sorting() && container->Check_If_Mesh_Fits(mmc)) {
|
|
container->Add_Mesh(mesh);
|
|
return;
|
|
}
|
|
it.Next();
|
|
}
|
|
|
|
container=new DX8RigidFVFCategoryContainer(fvf,sorting);
|
|
container_list->Add_Tail(container);
|
|
container->Add_Mesh(mesh);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void DX8MeshRendererClass::Unregister_Mesh_Type(MeshClass* mesh)
|
|
{
|
|
while (DX8PolygonRendererClass* n=mesh->PolygonRendererList.Remove_Head()) {
|
|
delete n;
|
|
}
|
|
_RegisteredMeshTable.Remove(MeshRegKeyStruct(mesh->Peek_Model(),mesh->Get_User_Lighting_Array()),mesh);
|
|
|
|
// Also remove the gap filler!
|
|
MeshModelClass * mmc = mesh->Peek_Model();
|
|
if (mmc->GapFiller) {
|
|
GapFillerClass* gf=mmc->GapFiller;
|
|
mmc->GapFiller=NULL;
|
|
delete gf;
|
|
}
|
|
}
|
|
|
|
|
|
void DX8MeshRendererClass::Register_Mesh_Type(MeshClass* mesh)
|
|
{
|
|
WWMEMLOG(MEM_GEOMETRY);
|
|
MeshModelClass * mmc = mesh->Peek_Model();
|
|
#ifdef ENABLE_CATEGORY_LOG
|
|
WWDEBUG_SAY(("Registering mesh: %s (%d polys, %d verts + %d gap polygons)\n",mmc->Get_Name(),mmc->Get_Polygon_Count(),mmc->Get_Vertex_Count(),mmc->Get_Gap_Filler_Polygon_Count()));
|
|
#endif
|
|
bool skin=(mmc->Get_Flag(MeshModelClass::SKIN) && mmc->VertexBoneLink);
|
|
bool sorting=((!!mmc->Get_Flag(MeshModelClass::SORT)) && WW3D::Is_Sorting_Enabled() && (mmc->Get_Sort_Level() == SORT_LEVEL_NONE));
|
|
|
|
if (skin) {
|
|
|
|
/*
|
|
** This mesh is a skin. Add it to a DX8SkinFVFCategoryContainer.
|
|
*/
|
|
WWASSERT(texture_category_container_list_skin);
|
|
|
|
FVFCategoryListIterator it(texture_category_container_list_skin);
|
|
while (!it.Is_Done()) {
|
|
DX8FVFCategoryContainer * container = it.Peek_Obj();
|
|
if (sorting==container->Is_Sorting() && container->Check_If_Mesh_Fits(mmc)) {
|
|
container->Add_Mesh(mesh);
|
|
return;
|
|
}
|
|
it.Next();
|
|
}
|
|
|
|
DX8FVFCategoryContainer * new_container=new DX8SkinFVFCategoryContainer(sorting);
|
|
texture_category_container_list_skin->Add_Tail(new_container);
|
|
new_container->Add_Mesh(mesh);
|
|
|
|
} else {
|
|
|
|
unsigned int * user_lighting = mesh->Get_User_Lighting_Array();
|
|
MeshClass * existing_mesh = _RegisteredMeshTable.Get(MeshRegKeyStruct(mmc,user_lighting));
|
|
if (existing_mesh != NULL) {
|
|
|
|
// We found another instance of this mesh model so we can simply clone the poly renderers
|
|
DX8PolygonRendererListIterator it(&(existing_mesh->PolygonRendererList));
|
|
while (!it.Is_Done()) {
|
|
DX8PolygonRendererClass * src_renderer=it.Peek_Obj();
|
|
DX8PolygonRendererClass * new_renderer = new DX8PolygonRendererClass(*src_renderer,mesh);
|
|
src_renderer->Get_Texture_Category()->Add_Polygon_Renderer(new_renderer);
|
|
it.Next();
|
|
}
|
|
|
|
} else {
|
|
|
|
// This mesh model either is not registered yet or has been registered with a
|
|
// different user lighting array. Simply add it into the system as if it is a
|
|
// completely unique mesh.
|
|
unsigned fvf=DX8FVFCategoryContainer::Define_FVF(mmc,user_lighting,enable_lighting);
|
|
|
|
/*
|
|
** Search for an existing FVF Category Container that matches this mesh
|
|
*/
|
|
for (int i=0;i<texture_category_container_lists_rigid.Count();++i) {
|
|
FVFCategoryList * list=texture_category_container_lists_rigid[i];
|
|
WWASSERT(list);
|
|
DX8FVFCategoryContainer * container=list->Peek_Head();
|
|
if (container && container->Get_FVF()!=fvf) continue;
|
|
|
|
Add_Rigid_Mesh_To_Container(list,fvf,mesh);
|
|
break;
|
|
}
|
|
|
|
if (i==texture_category_container_lists_rigid.Count()) {
|
|
|
|
/*
|
|
** We couldn't find an existing FVF category container so we have to add one. Future
|
|
** meshes that use this FVF will also be able to use this container.
|
|
*/
|
|
FVFCategoryList * new_fvf_category = new FVFCategoryList();
|
|
texture_category_container_lists_rigid.Add(new_fvf_category);
|
|
Add_Rigid_Mesh_To_Container(new_fvf_category,fvf,mesh);
|
|
}
|
|
|
|
/*
|
|
** Done processing the mesh, add its polygon renderers to the global registered mesh list
|
|
*/
|
|
if (mesh->PolygonRendererList.Is_Empty() == false) {
|
|
_RegisteredMeshTable.Insert(MeshRegKeyStruct(mmc,user_lighting),mesh);
|
|
}
|
|
else {
|
|
WWDEBUG_SAY(("Error: Register_Mesh_Type failed! file: %s line: %d\r\n",__FILE__,__LINE__));
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
static unsigned statistics_requested=0;
|
|
|
|
void DX8MeshRendererClass::Request_Log_Statistics()
|
|
{
|
|
statistics_requested=WW3D::Get_Frame_Count();
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
// Render all meshes that are added to visible lists
|
|
//
|
|
// ---------------------------------------------------------------------------
|
|
|
|
static void Render_FVF_Category_Container_List(FVFCategoryList& list)
|
|
{
|
|
FVFCategoryListIterator it(&list);
|
|
while (!it.Is_Done()) {
|
|
it.Peek_Obj()->Render();
|
|
it.Next();
|
|
}
|
|
}
|
|
|
|
static void Render_FVF_Category_Container_List_Delayed_Passes(FVFCategoryList& list)
|
|
{
|
|
FVFCategoryListIterator it(&list);
|
|
while (!it.Is_Done()) {
|
|
it.Peek_Obj()->Render_Delayed_Procedural_Material_Passes();
|
|
it.Next();
|
|
}
|
|
}
|
|
|
|
void DX8MeshRendererClass::Flush(void)
|
|
{
|
|
int i;
|
|
|
|
WWPROFILE("DX8MeshRenderer::Flush");
|
|
if (!camera) return;
|
|
Log_Statistics_String(true);
|
|
|
|
/*
|
|
** Render the FVF categories. Note that it is critical that skins be
|
|
** rendered *after* the rigid meshes. This is caused by the fact that an object may
|
|
** have its base passes disabled and a translucent procedural material pass rendered
|
|
** instead. In this case, technically we have to delay rendering of the material pass but
|
|
** for skins we just render these passes as we go because we can assume that the
|
|
** bulk of the meshes have already been drawn (there would be extra overhead involved
|
|
** in solving this for skins)
|
|
*/
|
|
for (i=0;i<texture_category_container_lists_rigid.Count();++i) {
|
|
Render_FVF_Category_Container_List(*texture_category_container_lists_rigid[i]);
|
|
}
|
|
|
|
Render_FVF_Category_Container_List(*texture_category_container_list_skin);
|
|
|
|
Render_Decal_Meshes();
|
|
|
|
/*
|
|
** Render the translucent procedural material passes that were applied to meshes that
|
|
** had their base passes disabled.
|
|
*/
|
|
for (i=0;i<texture_category_container_lists_rigid.Count();++i) {
|
|
Render_FVF_Category_Container_List_Delayed_Passes(*texture_category_container_lists_rigid[i]);
|
|
}
|
|
|
|
DX8Wrapper::Set_Vertex_Buffer(NULL);
|
|
DX8Wrapper::Set_Index_Buffer(NULL,0);
|
|
}
|
|
|
|
|
|
void DX8MeshRendererClass::Add_To_Render_List(DecalMeshClass * decalmesh)
|
|
{
|
|
WWASSERT(decalmesh != NULL);
|
|
decalmesh->Set_Next_Visible(visible_decal_meshes);
|
|
visible_decal_meshes = decalmesh;
|
|
}
|
|
|
|
void DX8MeshRendererClass::Render_Decal_Meshes(void)
|
|
{
|
|
DX8Wrapper::Set_DX8_Render_State(D3DRS_ZBIAS,8);
|
|
|
|
DecalMeshClass * decal_mesh = visible_decal_meshes;
|
|
while (decal_mesh != NULL) {
|
|
decal_mesh->Render();
|
|
decal_mesh = decal_mesh->Peek_Next_Visible();
|
|
}
|
|
visible_decal_meshes = NULL;
|
|
|
|
DX8Wrapper::Set_DX8_Render_State(D3DRS_ZBIAS,0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
static void Log_Container_List(FVFCategoryList& container_list,bool only_visible)
|
|
{
|
|
FVFCategoryListIterator it(&container_list);
|
|
while (!it.Is_Done()) {
|
|
it.Peek_Obj()->Log(only_visible);
|
|
it.Next();
|
|
}
|
|
}
|
|
|
|
void DX8MeshRendererClass::Log_Statistics_String(bool only_visible)
|
|
{
|
|
if (statistics_requested!=WW3D::Get_Frame_Count()) return;
|
|
|
|
for (int i=0;i<texture_category_container_lists_rigid.Count();++i) {
|
|
Log_Container_List(*texture_category_container_lists_rigid[i],only_visible);
|
|
}
|
|
Log_Container_List(*texture_category_container_list_skin,only_visible);
|
|
|
|
}
|
|
|
|
static void Invalidate_FVF_Category_Container_List(FVFCategoryList& list)
|
|
{
|
|
while (DX8FVFCategoryContainer* fvf_category=list.Remove_Head()) {
|
|
delete fvf_category;
|
|
}
|
|
}
|
|
|
|
void DX8MeshRendererClass::Invalidate()
|
|
{
|
|
WWMEMLOG(MEM_RENDERER);
|
|
_RegisteredMeshTable.Remove_All();
|
|
|
|
for (int i=0;i<texture_category_container_lists_rigid.Count();++i) {
|
|
Invalidate_FVF_Category_Container_List(*texture_category_container_lists_rigid[i]);
|
|
delete texture_category_container_lists_rigid[i];
|
|
}
|
|
if (texture_category_container_list_skin) {
|
|
Invalidate_FVF_Category_Container_List(*texture_category_container_list_skin);
|
|
delete texture_category_container_list_skin;
|
|
texture_category_container_list_skin=NULL;
|
|
}
|
|
texture_category_container_list_skin = new FVFCategoryList;
|
|
|
|
texture_category_container_lists_rigid.Delete_All();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|