nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/WW3D/max2w3d/w3dmtl.cpp

1240 lines
35 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Generals Zero Hour(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 : Max2W3d *
* *
* $Archive:: /Commando/Code/Tools/max2w3d/w3dmtl.cpp $*
* *
* $Author:: Greg_h $*
* *
* $Modtime:: 8/22/01 7:47a $*
* *
* $Revision:: 32 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "w3dmtl.h"
#include <Max.h>
#include <StdMat.h>
#include "gamemtl.h"
#include "realcrc.h"
static W3dRGBStruct Color_To_W3d(Color & c)
{
W3dRGBStruct wc;
wc.R = (c.r * 255.0f);
wc.G = (c.g * 255.0f);
wc.B = (c.b * 255.0f);
wc.pad = 0;
return wc;
}
/*
Implementation of W3dMapClass
*/
W3dMapClass::W3dMapClass(const W3dMapClass & that)
{
Set_Filename(that.Filename);
if (that.AnimInfo) {
Set_Anim_Info(that.AnimInfo);
}
}
W3dMapClass & W3dMapClass::operator = (const W3dMapClass & that)
{
if (this != &that) {
Set_Filename(that.Filename);
Set_Anim_Info(that.AnimInfo);
}
return *this;
}
W3dMapClass::~W3dMapClass(void)
{
if (Filename) free(Filename);
if (AnimInfo) delete AnimInfo;
}
void W3dMapClass::Reset(void)
{
if (Filename) free(Filename);
if (AnimInfo) delete AnimInfo;
Filename = NULL;
AnimInfo = NULL;
}
void W3dMapClass::Set_Filename(const char * fullpath)
{
if (Filename) {
free(Filename);
}
if (fullpath) {
char name[_MAX_FNAME];
char exten[_MAX_EXT];
char fname[_MAX_FNAME+_MAX_EXT+2];
_splitpath(fullpath,NULL,NULL,name,exten);
_makepath(fname,NULL,NULL,name,exten);
//strupr(fname); (gth) need to preserve case since unix/PS2 is case sensitive...
Filename = strdup(fname);
} else {
Filename = NULL;
}
}
void W3dMapClass::Set_Anim_Info(const W3dTextureInfoStruct * info)
{
if (info == NULL) {
if (AnimInfo) {
delete AnimInfo;
AnimInfo = NULL;
return;
}
} else {
if (AnimInfo == NULL) {
AnimInfo = new W3dTextureInfoStruct;
}
*AnimInfo = *info;
}
}
void W3dMapClass::Set_Anim_Info(int framecount,float framerate)
{
if (AnimInfo == NULL) {
AnimInfo = new W3dTextureInfoStruct;
}
AnimInfo->FrameCount = framecount;
AnimInfo->FrameRate = framerate;
}
/*
Implementation of W3dMaterialClass
*/
W3dMaterialClass::W3dMaterialClass(void)
{
PassCount = 0;
SortLevel = SORT_LEVEL_NONE;
for (int pass = 0; pass < MAX_PASSES; pass++) {
Materials[pass] = NULL;
W3d_Shader_Reset(&(Shaders[pass]));
for (int stage = 0; stage < MAX_STAGES; stage++) {
Textures[pass][stage] = NULL;
MapChannel[pass][stage] = 1;
MapperArgs[pass][stage] = NULL;
}
}
}
W3dMaterialClass::~W3dMaterialClass(void)
{
Free();
}
void W3dMaterialClass::Free(void)
{
for (int pass = 0; pass < MAX_PASSES; pass++) {
if (Materials[pass]) {
delete Materials[pass];
Materials[pass] = NULL;
}
for (int stage = 0; stage < MAX_STAGES; stage++) {
if (Textures[pass][stage]) {
delete Textures[pass][stage];
Textures[pass][stage] = NULL;
}
if (MapperArgs[pass][stage]) {
delete [] MapperArgs[pass][stage];
MapperArgs[pass][stage] = NULL;
}
}
}
}
void W3dMaterialClass::Reset(void)
{
Free();
SortLevel = SORT_LEVEL_NONE;
for (int pass=0; pass < MAX_PASSES; pass++) {
W3d_Shader_Reset(&(Shaders[pass]));
for (int stage=0; stage < MAX_STAGES; stage++) {
MapChannel[pass][stage] = 1;
}
}
}
void W3dMaterialClass::Set_Surface_Type(unsigned int type)
{
SurfaceType = type;
}
void W3dMaterialClass::Set_Sort_Level(int level)
{
assert(level <= MAX_SORT_LEVEL);
SortLevel = level;
}
void W3dMaterialClass::Set_Pass_Count(int count)
{
assert(count >= 0);
assert(count < MAX_PASSES);
PassCount = count;
}
void W3dMaterialClass::Set_Vertex_Material(const W3dVertexMaterialStruct & vmat,int pass)
{
assert(pass >= 0);
assert(pass < PassCount);
if (Materials[pass] == NULL) {
Materials[pass] = new W3dVertexMaterialStruct;
}
*(Materials[pass]) = vmat;
}
void W3dMaterialClass::Set_Mapper_Args(const char *args_buffer, int pass, int stage)
{
assert(pass >= 0);
assert(pass < PassCount);
assert(stage >= 0);
assert(stage < MAX_STAGES);
if (MapperArgs[pass][stage] != NULL) {
delete [] MapperArgs[pass][stage];
MapperArgs[pass][stage] = NULL;
}
if (args_buffer) {
int len = strlen(args_buffer);
MapperArgs[pass][stage] = new char [len + 1];
strcpy(MapperArgs[pass][stage], args_buffer);
}
}
void W3dMaterialClass::Set_Shader(const W3dShaderStruct & shader,int pass)
{
assert(pass >= 0);
assert(pass < PassCount);
Shaders[pass] = shader;
}
void W3dMaterialClass::Set_Texture(const W3dMapClass & map,int pass,int stage)
{
assert(pass >= 0);
assert(pass < PassCount);
if (Textures[pass][stage] == NULL) {
Textures[pass][stage] = new W3dMapClass;
}
*(Textures[pass][stage]) = map;
}
void W3dMaterialClass::Set_Map_Channel(int pass,int stage,int channel)
{
assert(pass >= 0);
assert(pass < PassCount);
MapChannel[pass][stage] = channel;
}
unsigned int W3dMaterialClass::Get_Surface_Type(void) const
{
return SurfaceType;
}
int W3dMaterialClass::Get_Sort_Level(void) const
{
return SortLevel;
}
int W3dMaterialClass::Get_Pass_Count(void) const
{
return PassCount;
}
W3dVertexMaterialStruct * W3dMaterialClass::Get_Vertex_Material(int pass ) const
{
assert(pass >= 0);
assert(pass < PassCount);
return Materials[pass];
}
const char * W3dMaterialClass::Get_Mapper_Args(int pass, int stage) const
{
assert(pass >= 0);
assert(pass < PassCount);
assert(stage >= 0);
assert(stage < MAX_STAGES);
return MapperArgs[pass][stage];
}
W3dShaderStruct W3dMaterialClass::Get_Shader(int pass) const
{
assert(pass >= 0);
assert(pass < PassCount);
return Shaders[pass];
}
W3dMapClass * W3dMaterialClass::Get_Texture(int pass,int stage) const
{
assert(pass >= 0);
assert(pass < PassCount);
assert(stage >= 0);
assert(stage < MAX_STAGES);
return Textures[pass][stage];
}
int W3dMaterialClass::Get_Map_Channel(int pass,int stage) const
{
assert(pass >= 0);
assert(pass < PassCount);
assert(stage >= 0);
assert(stage < MAX_STAGES);
return MapChannel[pass][stage];
}
void W3dMaterialClass::Init(Mtl * mtl, char *materialColorTexture)
{
bool ps2_mat = false;
Reset();
if (mtl->ClassID() == PS2GameMaterialClassID)
{
ps2_mat = true;
}
if ((mtl->ClassID() == GameMaterialClassID) || ps2_mat) {
Init((GameMtl*)mtl, materialColorTexture); ///@todo: Fix this for substituted textures.
return;
}
Texmap * tmap;
PassCount = 1;
tmap = mtl->GetSubTexmap(ID_RL);
if (tmap && tmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0)) {
PassCount++;
}
W3dVertexMaterialStruct mat;
W3dShaderStruct shader;
W3dMapClass tex;
/*
** Setting up the diffuse color pass
*/
W3d_Shader_Reset(&shader);
mat.Attributes = 0;
mat.Emissive.R = mat.Emissive.G = mat.Emissive.B = 0; //(uint8)(255 .0f * mtl->GetSelfIllum());
Color diffuse = mtl->GetDiffuse();
mat.Diffuse.R = (uint8)(diffuse.r * 255.0f);
mat.Diffuse.G = (uint8)(diffuse.g * 255.0f);
mat.Diffuse.B = (uint8)(diffuse.b * 255.0f);
mat.Ambient = mat.Diffuse;
Color specular = mtl->GetSpecular();
mat.Specular.R = (uint8)(specular.r * 255.0f);
mat.Specular.G = (uint8)(specular.g * 255.0f);
mat.Specular.B = (uint8)(specular.b * 255.0f);
mat.Shininess = mtl->GetShininess();
mat.Opacity = 1.0f - mtl->GetXParency();
mat.Translucency = 0.0f;
tmap = mtl->GetSubTexmap(ID_DI);
if (tmap && tmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0)) {
char * tname = ((BitmapTex *)tmap)->GetMapName();
if (tname) {
tex.Set_Filename(tname);
mat.Diffuse.R = mat.Diffuse.G = mat.Diffuse.B = 255;
W3d_Shader_Set_Texturing(&shader,W3DSHADER_TEXTURING_ENABLE);
Set_Texture(tex,0,0);
}
}
if (materialColorTexture && !mtl->GetSubTexmap(ID_DI) && !mtl->GetSubTexmap(ID_RL))
{ //no textures on material, substitute textures to improve rendering speed.
tex.Set_Filename(materialColorTexture); ///@todo: Fix this to procedural name/path
W3d_Shader_Set_Texturing(&shader,W3DSHADER_TEXTURING_ENABLE);
//This texture will hold solid pixels of material color, don't need any filtering.
// W3dTextureInfoStruct texinfo;
// memset(&texinfo,0,sizeof(texinfo));
// texinfo.Attributes = texinfo.Attributes | /*W3DTEXTURE_NO_LOD|*/W3DTEXTURE_CLAMP_U | W3DTEXTURE_CLAMP_V;
// tex.Set_Anim_Info(&texinfo);
Set_Texture(tex,0,0);
}
if (mat.Opacity != 1.0f) {
W3d_Shader_Set_Dest_Blend_Func(&shader,W3DSHADER_DESTBLENDFUNC_ONE_MINUS_SRC_ALPHA);
W3d_Shader_Set_Src_Blend_Func(&shader,W3DSHADER_SRCBLENDFUNC_SRC_ALPHA);
}
Set_Vertex_Material(mat,0);
Set_Shader(shader,0);
/*
** Setting up the reflection pass (envmap)
*/
if (PassCount == 2) {
W3d_Shader_Reset(&shader);
if (ps2_mat)
{
W3d_Shader_Set_Pri_Gradient(&shader,PSS_PRIGRADIENT_MODULATE);
}
else
{
W3d_Shader_Set_Pri_Gradient(&shader,W3DSHADER_PRIGRADIENT_MODULATE);
}
W3d_Shader_Set_Sec_Gradient(&shader,W3DSHADER_SECGRADIENT_DISABLE);
W3d_Shader_Set_Depth_Mask(&shader,W3DSHADER_DEPTHMASK_WRITE_DISABLE);
W3d_Shader_Set_Dest_Blend_Func(&shader,W3DSHADER_DESTBLENDFUNC_ONE);
W3d_Shader_Set_Src_Blend_Func(&shader,W3DSHADER_SRCBLENDFUNC_ONE);
W3d_Shader_Set_Texturing(&shader,W3DSHADER_TEXTURING_ENABLE);
// PS2 specific paramaters.
W3d_Shader_Set_PS2_Param_A(&shader, PSS_SRC);
W3d_Shader_Set_PS2_Param_B(&shader, PSS_ZERO);
W3d_Shader_Set_PS2_Param_B(&shader, PSS_ONE);
W3d_Shader_Set_PS2_Param_B(&shader, PSS_DEST);
W3d_Vertex_Material_Reset(&mat);
mat.Diffuse.R = mat.Diffuse.G = mat.Diffuse.B = 128;
mat.Attributes &= W3DVERTMAT_STAGE0_MAPPING_MASK;
mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_ENVIRONMENT;
tmap = mtl->GetSubTexmap(ID_RL);
if (tmap && tmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0)) {
char * tname = ((BitmapTex *)tmap)->GetMapName();
if (tname) {
tex.Set_Filename(tname);
Set_Texture(tex,1);
}
}
Set_Vertex_Material(mat,1);
Set_Shader(shader,1);
}
}
void W3dMaterialClass::Init(GameMtl * gamemtl, char *materialColorTexture)
{
Reset();
PassCount = gamemtl->Get_Pass_Count();
Set_Surface_Type (gamemtl->Get_Surface_Type ());
Set_Sort_Level(gamemtl->Get_Sort_Level());
for (int pass=0;pass<gamemtl->Get_Pass_Count(); pass++) {
/*
** set up the shader
*/
W3dShaderStruct shader;
W3d_Shader_Reset(&shader);
shader.DepthCompare = gamemtl->Get_Depth_Compare(pass);
shader.DepthMask = gamemtl->Get_Depth_Mask(pass);
shader.AlphaTest = gamemtl->Get_Alpha_Test(pass);
shader.DestBlend = gamemtl->Get_Dest_Blend(pass);
shader.PriGradient = gamemtl->Get_Pri_Gradient(pass);
shader.SecGradient = gamemtl->Get_Sec_Gradient(pass);
shader.SrcBlend = gamemtl->Get_Src_Blend(pass);
shader.DetailColorFunc = gamemtl->Get_Detail_Color_Func(pass);
shader.DetailAlphaFunc = gamemtl->Get_Detail_Alpha_Func(pass);
shader.Texturing = W3DSHADER_TEXTURING_DISABLE;
shader.PostDetailColorFunc = gamemtl->Get_Detail_Color_Func(pass); // (gth) set up the post-detail options
shader.PostDetailAlphaFunc = gamemtl->Get_Detail_Alpha_Func(pass);
// PS2 specific paramaters.
W3d_Shader_Set_PS2_Param_A(&shader, gamemtl->Get_PS2_Shader_Param_A(pass));
W3d_Shader_Set_PS2_Param_B(&shader, gamemtl->Get_PS2_Shader_Param_B(pass));
W3d_Shader_Set_PS2_Param_C(&shader, gamemtl->Get_PS2_Shader_Param_C(pass));
W3d_Shader_Set_PS2_Param_D(&shader, gamemtl->Get_PS2_Shader_Param_D(pass));
/*
** set up the vertex material
*/
W3dVertexMaterialStruct mat;
mat.Attributes = 0;
if (gamemtl->Get_Copy_Specular_To_Diffuse(pass)) {
mat.Attributes |= W3DVERTMAT_COPY_SPECULAR_TO_DIFFUSE;
}
// mapping type for stage 0
switch(gamemtl->Get_Mapping_Type(pass, 0))
{
case GAMEMTL_MAPPING_UV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_UV; break;
case GAMEMTL_MAPPING_ENV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_ENVIRONMENT; break;
case GAMEMTL_MAPPING_CHEAP_ENV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_CHEAP_ENVIRONMENT; break;
case GAMEMTL_MAPPING_SCREEN: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_SCREEN; break;
case GAMEMTL_MAPPING_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_SILHOUETTE: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_SILHOUETTE; break;
case GAMEMTL_MAPPING_SCALE: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_SCALE; break;
case GAMEMTL_MAPPING_GRID: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_GRID; break;
case GAMEMTL_MAPPING_ROTATE: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_ROTATE; break;
case GAMEMTL_MAPPING_SINE_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_SINE_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_STEP_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_STEP_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_ZIGZAG_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_ZIGZAG_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_WS_CLASSIC_ENV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_WS_CLASSIC_ENV; break;
case GAMEMTL_MAPPING_WS_ENVIRONMENT: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_WS_ENVIRONMENT; break;
case GAMEMTL_MAPPING_GRID_CLASSIC_ENV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_GRID_CLASSIC_ENV; break;
case GAMEMTL_MAPPING_GRID_ENVIRONMENT: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_GRID_ENVIRONMENT; break;
case GAMEMTL_MAPPING_RANDOM: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_RANDOM; break;
case GAMEMTL_MAPPING_EDGE: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_EDGE; break;
case GAMEMTL_MAPPING_BUMPENV: mat.Attributes |= W3DVERTMAT_STAGE0_MAPPING_BUMPENV; break;
};
// mapping type for stage 1
switch(gamemtl->Get_Mapping_Type(pass, 1))
{
case GAMEMTL_MAPPING_UV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_UV; break;
case GAMEMTL_MAPPING_ENV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_ENVIRONMENT; break;
case GAMEMTL_MAPPING_CHEAP_ENV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_CHEAP_ENVIRONMENT; break;
case GAMEMTL_MAPPING_SCREEN: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_SCREEN; break;
case GAMEMTL_MAPPING_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_SILHOUETTE: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_SILHOUETTE; break;
case GAMEMTL_MAPPING_SCALE: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_SCALE; break;
case GAMEMTL_MAPPING_GRID: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_GRID; break;
case GAMEMTL_MAPPING_ROTATE: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_ROTATE; break;
case GAMEMTL_MAPPING_SINE_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_SINE_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_STEP_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_STEP_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_ZIGZAG_LINEAR_OFFSET: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_ZIGZAG_LINEAR_OFFSET; break;
case GAMEMTL_MAPPING_WS_CLASSIC_ENV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_WS_CLASSIC_ENV; break;
case GAMEMTL_MAPPING_WS_ENVIRONMENT: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_WS_ENVIRONMENT; break;
case GAMEMTL_MAPPING_GRID_CLASSIC_ENV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_GRID_CLASSIC_ENV; break;
case GAMEMTL_MAPPING_GRID_ENVIRONMENT: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_GRID_ENVIRONMENT; break;
case GAMEMTL_MAPPING_RANDOM: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_RANDOM; break;
case GAMEMTL_MAPPING_EDGE: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_EDGE; break;
case GAMEMTL_MAPPING_BUMPENV: mat.Attributes |= W3DVERTMAT_STAGE1_MAPPING_BUMPENV; break;
};
switch(gamemtl->Get_PSX_Translucency(pass))
{
case GAMEMTL_PSX_TRANS_NONE: mat.Attributes |= W3DVERTMAT_PSX_TRANS_NONE; break;
case GAMEMTL_PSX_TRANS_100: mat.Attributes |= W3DVERTMAT_PSX_TRANS_100; break;
case GAMEMTL_PSX_TRANS_50: mat.Attributes |= W3DVERTMAT_PSX_TRANS_50; break;
case GAMEMTL_PSX_TRANS_25: mat.Attributes |= W3DVERTMAT_PSX_TRANS_25; break;
case GAMEMTL_PSX_TRANS_MINUS_100:mat.Attributes |= W3DVERTMAT_PSX_TRANS_MINUS_100; break;
};
if (!gamemtl->Get_PSX_Lighting(pass)) {
mat.Attributes |= W3DVERTMAT_PSX_NO_RT_LIGHTING;
}
mat.Ambient = Color_To_W3d(gamemtl->Get_Ambient(pass,0));
mat.Diffuse = Color_To_W3d(gamemtl->Get_Diffuse(pass,0));
mat.Specular = Color_To_W3d(gamemtl->Get_Specular(pass,0));
mat.Emissive = Color_To_W3d(gamemtl->Get_Emissive(pass,0));
mat.Shininess = gamemtl->Get_Shininess(pass,0);
mat.Opacity = gamemtl->Get_Opacity(pass,0);
mat.Translucency = gamemtl->Get_Translucency(pass,0);
/*
** install the two textures if present
*/
W3dMapClass w3dmap;
BitmapTex * tex = NULL;
for (int stage=0; stage < MAX_STAGES; stage++) {
if (gamemtl->Get_Texture_Enable(pass,stage) && gamemtl->Get_Texture(pass,stage)) {
w3dmap.Reset();
// get the filename for the w3dmap texture
tex = (BitmapTex *)gamemtl->Get_Texture(pass,stage);
assert(tex->GetMapName());
w3dmap.Set_Filename(tex->GetMapName());
// get the animation and flags for the w3dmap texture
W3dTextureInfoStruct texinfo;
memset(&texinfo,0,sizeof(texinfo));
texinfo.AnimType = gamemtl->Get_Texture_Anim_Type(pass,stage);
if (gamemtl->Get_Texture_Publish(pass,stage)) {
texinfo.Attributes = texinfo.Attributes | W3DTEXTURE_PUBLISH;
}
if (gamemtl->Get_Texture_No_LOD(pass,stage)) {
texinfo.Attributes = texinfo.Attributes | W3DTEXTURE_NO_LOD;
}
if (gamemtl->Get_Texture_Clamp_U(pass,stage)) {
texinfo.Attributes = texinfo.Attributes | W3DTEXTURE_CLAMP_U;
}
if (gamemtl->Get_Texture_Clamp_V(pass,stage)) {
texinfo.Attributes = texinfo.Attributes | W3DTEXTURE_CLAMP_V;
}
if (gamemtl->Get_Texture_Alpha_Bitmap(pass,stage)) {
texinfo.Attributes = texinfo.Attributes | W3DTEXTURE_ALPHA_BITMAP;
}
texinfo.Attributes = texinfo.Attributes | (
(gamemtl->Get_Texture_Hint(pass,stage) << W3DTEXTURE_HINT_SHIFT)
& W3DTEXTURE_HINT_MASK);
// If the shader indicates bump-environment mapping mark this texture as a bumpmap.
if ((stage == 0) && (gamemtl->Get_Pri_Gradient (pass) == W3DSHADER_PRIGRADIENT_BUMPENVMAP)) {
texinfo.Attributes |= W3DTEXTURE_TYPE_BUMPMAP;
}
texinfo.FrameCount = gamemtl->Get_Texture_Frame_Count(pass,stage);
texinfo.FrameRate = gamemtl->Get_Texture_Frame_Rate(pass,stage);
if ((texinfo.FrameCount > 1) || (texinfo.Attributes != 0)) {
w3dmap.Set_Anim_Info(&texinfo);
}
// plug it in and turn on texturing in the shader
Set_Texture(w3dmap,pass,stage);
shader.Texturing = W3DSHADER_TEXTURING_ENABLE;
// copy over the mapping channel
Set_Map_Channel(pass,stage,gamemtl->Get_Map_Channel(pass,stage));
// copy over the mapper args
Set_Mapper_Args(gamemtl->Get_Mapping_Arg_Buffer(pass, stage), pass, stage);
} else {
if (materialColorTexture)
{ //no textures on material, substitute textures to improve rendering speed.
w3dmap.Reset();
w3dmap.Set_Filename(materialColorTexture);
// plug it in and turn on texturing in the shader
Set_Texture(w3dmap,pass,stage);
shader.Texturing = W3DSHADER_TEXTURING_ENABLE;
}
break; // break out of the loop (and dont put in stage 1 if stage 0 is missing...)
}
}
Set_Shader(shader,pass);
Set_Vertex_Material(mat,pass);
}
}
bool W3dMaterialClass::Is_Multi_Pass_Transparent(void) const
{
return ((PassCount >= 2) && (Get_Shader(0).DestBlend != W3DSHADER_DESTBLENDFUNC_ZERO));
}
/*
Implementation of W3dMaterialDescClass::VertClass
*/
W3dMaterialDescClass::VertMatClass::VertMatClass(void) :
PassIndex(-1),
Crc(0),
Name(NULL)
{
for (int stage=0; stage < W3dMaterialClass::MAX_STAGES; ++stage) {
MapperArgs[stage] = NULL;
}
}
W3dMaterialDescClass::VertMatClass::~VertMatClass(void)
{
if (Name) free(Name);
for (int stage=0; stage < W3dMaterialClass::MAX_STAGES; ++stage) {
if (MapperArgs[stage]) {
delete [] (MapperArgs[stage]);
MapperArgs[stage] = NULL;
}
}
}
W3dMaterialDescClass::VertMatClass &
W3dMaterialDescClass::VertMatClass::operator = (const VertMatClass & that)
{
if (this != &that) {
Material = that.Material;
PassIndex = that.PassIndex;
Crc = that.Crc;
Set_Name(that.Name);
for (int stage=0; stage < W3dMaterialClass::MAX_STAGES; stage++) {
Set_Mapper_Args(that.MapperArgs[stage], stage);
}
}
return *this;
}
bool W3dMaterialDescClass::VertMatClass::operator != (const VertMatClass & that)
{
return !(*this == that);
}
bool W3dMaterialDescClass::VertMatClass::operator == (const VertMatClass & that)
{
assert(0); return false;
}
void W3dMaterialDescClass::VertMatClass::Set_Name(const char * name)
{
if (Name) free(Name);
if (name) {
Name = strdup(name);
} else {
Name = NULL;
}
}
void W3dMaterialDescClass::VertMatClass::Set_Mapper_Args(const char * args, int stage)
{
if (MapperArgs[stage]) {
delete [] (MapperArgs[stage]);
MapperArgs[stage] = NULL;
}
if (args) {
int len = strlen(args);
MapperArgs[stage] = new char [len + 1];
strcpy(MapperArgs[stage], args);
} else {
MapperArgs[stage] = NULL;
}
}
/*
Implementation of W3dMaterialDescClass
*/
W3dMaterialDescClass::MaterialRemapClass::MaterialRemapClass(void)
{
PassCount = -1;
for (int pass=0; pass<W3dMaterialClass::MAX_PASSES; pass++) {
VertexMaterialIdx[pass] = -1;
ShaderIdx[pass] = -1;
for (int stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++) {
TextureIdx[pass][stage] = -1;
}
}
}
bool W3dMaterialDescClass::MaterialRemapClass::operator != (const MaterialRemapClass & that)
{
return !(*this == that);
}
bool W3dMaterialDescClass::MaterialRemapClass::operator == (const MaterialRemapClass & that)
{
for (int pass=0; pass<W3dMaterialClass::MAX_PASSES; pass++) {
if (VertexMaterialIdx[pass] != that.VertexMaterialIdx[pass]) return false;
if (ShaderIdx[pass] != that.ShaderIdx[pass]) return false;
for (int stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++) {
if (TextureIdx[pass][stage] != that.TextureIdx[pass][stage]) return false;
}
}
return true;
}
W3dMaterialDescClass::W3dMaterialDescClass(void)
{
Reset();
}
W3dMaterialDescClass::~W3dMaterialDescClass(void)
{
}
void W3dMaterialDescClass::Reset(void)
{
PassCount = -1;
SortLevel = -1;
MaterialRemaps.Clear();
Shaders.Clear();
VertexMaterials.Clear();
Textures.Clear();
}
W3dMaterialDescClass::ErrorType W3dMaterialDescClass::Add_Material(const W3dMaterialClass & mat,const char * name)
{
/*
** If passes hasn't been set yet, set it.
*/
if (PassCount == -1) {
PassCount = mat.Get_Pass_Count();
}
/*
** Same for sort level.
*/
if (SortLevel == -1) {
SortLevel = mat.Get_Sort_Level();
}
/*
** Verify that this material uses the same number of passes that any
** other materials we have use.
*/
if (mat.Get_Pass_Count() != PassCount) {
return INCONSISTENT_PASSES;
}
if (mat.Is_Multi_Pass_Transparent()) {
char msg[100];
sprintf(msg,"Enable Multipass-Transparency?");
HWND window=GetForegroundWindow();
if (IDYES!=MessageBox(window,msg,"Confirmation",MB_YESNO|MB_ICONINFORMATION|MB_TASKMODAL))
return MULTIPASS_TRANSPARENT;
}
/*
** Verify that this material uses the same sort level as all other
** materials used on this mesh.
*/
if (mat.Get_Sort_Level() != SortLevel) {
return INCONSISTENT_SORT_LEVEL;
}
/*
** Ok, lets re-index this material and store the unique parts
*/
MaterialRemapClass remap;
for (int pass=0; pass<PassCount; pass++) {
remap.VertexMaterialIdx[pass] = Add_Vertex_Material(
mat.Get_Vertex_Material(pass),mat.Get_Mapper_Args(pass, 0),mat.Get_Mapper_Args(pass, 1),pass,name);
remap.ShaderIdx[pass] = Add_Shader(mat.Get_Shader(pass),pass);
for (int stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++) {
remap.TextureIdx[pass][stage] = Add_Texture(mat.Get_Texture(pass,stage),pass,stage);
remap.MapChannel[pass][stage] = mat.Get_Map_Channel(pass,stage);
}
}
MaterialRemaps.Add(remap);
return OK;
}
int W3dMaterialDescClass::Material_Count(void)
{
return MaterialRemaps.Count();
}
int W3dMaterialDescClass::Pass_Count(void)
{
return PassCount;
}
int W3dMaterialDescClass::Vertex_Material_Count(void)
{
return VertexMaterials.Count();
}
int W3dMaterialDescClass::Shader_Count(void)
{
return Shaders.Count();
}
int W3dMaterialDescClass::Texture_Count(void)
{
return Textures.Count();
}
int W3dMaterialDescClass::Get_Sort_Level(void)
{
return SortLevel;
}
W3dVertexMaterialStruct * W3dMaterialDescClass::Get_Vertex_Material(int vmat_index)
{
assert(vmat_index >= 0);
assert(vmat_index < VertexMaterials.Count());
return &(VertexMaterials[vmat_index].Material);
}
const char * W3dMaterialDescClass::Get_Mapper_Args(int vmat_index, int stage)
{
assert(vmat_index >= 0);
assert(vmat_index < VertexMaterials.Count());
assert(stage >= 0);
assert(stage < W3dMaterialClass::MAX_STAGES);
return VertexMaterials[vmat_index].MapperArgs[stage];
}
W3dShaderStruct * W3dMaterialDescClass::Get_Shader(int shader_index)
{
assert(shader_index >= 0);
assert(shader_index < Shaders.Count());
return &(Shaders[shader_index].Shader);
}
W3dMapClass * W3dMaterialDescClass::Get_Texture(int texture_index)
{
assert(texture_index >= 0);
assert(texture_index < Textures.Count());
return &(Textures[texture_index].Map);
}
int W3dMaterialDescClass::Get_Vertex_Material_Index(int mat_index,int pass)
{
assert(mat_index >= 0);
assert(mat_index < MaterialRemaps.Count());
assert(pass >= 0);
assert(pass < PassCount);
return MaterialRemaps[mat_index].VertexMaterialIdx[pass];
}
int W3dMaterialDescClass::Get_Shader_Index(int mat_index,int pass)
{
assert(mat_index >= 0);
assert(mat_index < MaterialRemaps.Count());
assert(pass >= 0);
assert(pass < PassCount);
return MaterialRemaps[mat_index].ShaderIdx[pass];
}
int W3dMaterialDescClass::Get_Texture_Index(int mat_index,int pass,int stage)
{
assert(mat_index >= 0);
assert(mat_index < MaterialRemaps.Count());
assert(pass >= 0);
assert(pass < PassCount);
assert(stage >= 0);
assert(stage < W3dMaterialClass::MAX_STAGES);
return MaterialRemaps[mat_index].TextureIdx[pass][stage];
}
W3dVertexMaterialStruct * W3dMaterialDescClass::Get_Vertex_Material(int mat_index,int pass)
{
int index = Get_Vertex_Material_Index(mat_index,pass);
if (index == -1) {
return NULL;
} else {
return Get_Vertex_Material(index);
}
}
const char * W3dMaterialDescClass::Get_Mapper_Args(int mat_index,int pass,int stage)
{
int index = Get_Vertex_Material_Index(mat_index,pass);
if (index == -1) {
return NULL;
} else {
return Get_Mapper_Args(index,stage);
}
}
W3dShaderStruct * W3dMaterialDescClass::Get_Shader(int mat_index,int pass)
{
int index = Get_Shader_Index(mat_index,pass);
if (index == -1) {
return NULL;
} else {
return Get_Shader(index);
}
}
W3dMapClass * W3dMaterialDescClass::Get_Texture(int mat_index,int pass,int stage)
{
int index = Get_Texture_Index(mat_index,pass,stage);
if (index == -1) {
return NULL;
} else {
return Get_Texture(index);
}
}
int W3dMaterialDescClass::Get_Map_Channel(int mat_index,int pass,int stage)
{
return MaterialRemaps[mat_index].MapChannel[pass][stage];
}
const char * W3dMaterialDescClass::Get_Vertex_Material_Name(int mat_index,int pass)
{
int index = Get_Vertex_Material_Index(mat_index,pass);
if (index == -1) {
return NULL;
} else {
return VertexMaterials[index].Name;
}
}
const char * W3dMaterialDescClass::Get_Vertex_Material_Name(int vmat_index)
{
return VertexMaterials[vmat_index].Name;
}
bool W3dMaterialDescClass::Stage_Needs_Texture_Coordinates(int pass,int stage)
{
for (int mi=0; mi<MaterialRemaps.Count();mi++) {
W3dShaderStruct * shader = Get_Shader(mi,pass);
if (shader) {
if (stage == 0) {
if (W3d_Shader_Get_Texturing(shader) == W3DSHADER_TEXTURING_ENABLE) return true;
}
if (stage == 1) {
if ((W3d_Shader_Get_Detail_Color_Func(shader) != W3DSHADER_DETAILCOLORFUNC_DISABLE) ||
(W3d_Shader_Get_Detail_Alpha_Func(shader) != W3DSHADER_DETAILALPHAFUNC_DISABLE)) {
return true;
}
}
}
}
return false;
}
bool W3dMaterialDescClass::Pass_Uses_Vertex_Alpha(int pass)
{
/*
** Only the last alpha pass gets vertex alpha
*/
int max_alpha_pass = -1;
for (int pi=0; pi<Pass_Count(); pi++) {
if (Pass_Uses_Alpha(pi)) {
max_alpha_pass = pi;
}
}
return (max_alpha_pass == pass);
}
bool W3dMaterialDescClass::Pass_Uses_Alpha(int pass)
{
for (int mi=0; mi<MaterialRemaps.Count(); mi++) {
W3dShaderStruct * shader = Get_Shader(mi,pass);
int dst_blend = W3d_Shader_Get_Dest_Blend_Func(shader);
int src_blend = W3d_Shader_Get_Src_Blend_Func(shader);
int alpha_test = W3d_Shader_Get_Alpha_Test(shader);
if ( (dst_blend == W3DSHADER_DESTBLENDFUNC_SRC_ALPHA) ||
(dst_blend == W3DSHADER_DESTBLENDFUNC_ONE_MINUS_SRC_ALPHA) ||
(src_blend == W3DSHADER_SRCBLENDFUNC_SRC_ALPHA) ||
(src_blend == W3DSHADER_SRCBLENDFUNC_ONE_MINUS_SRC_ALPHA) ||
(alpha_test != 0) )
{
return true;
}
}
return false;
}
int W3dMaterialDescClass::Add_Vertex_Material(W3dVertexMaterialStruct * vmat,
const char *mapper_args0,const char *mapper_args1,int pass,const char * name)
{
if (vmat == NULL) {
return -1;
}
int crc = Compute_Crc(*vmat, mapper_args0, mapper_args1);
for (int vi=0; vi<VertexMaterials.Count(); vi++) {
if ((crc == VertexMaterials[vi].Crc) && (pass == VertexMaterials[vi].PassIndex)) {
break;
}
}
if (vi == VertexMaterials.Count()) {
VertMatClass vm;
vm.Material = *vmat;
vm.Crc = crc;
vm.PassIndex = pass;
vm.Set_Name(name);
vm.Set_Mapper_Args(mapper_args0, 0);
vm.Set_Mapper_Args(mapper_args1, 1);
VertexMaterials.Add(vm);
}
return vi;
}
int W3dMaterialDescClass::Add_Shader(const W3dShaderStruct & shader,int pass)
{
int crc = Compute_Crc(shader);
for (int si=0; si<Shaders.Count(); si++) {
if (crc == Shaders[si].Crc) break;
}
if (si == Shaders.Count()) {
ShadeClass s;
s.Shader = shader;
s.Crc = crc;
Shaders.Add(s);
}
return si;
}
int W3dMaterialDescClass::Add_Texture(W3dMapClass * map,int pass,int stage)
{
if ((map == NULL) || (map->Filename == NULL)) {
return -1;
}
int crc = Compute_Crc(*map);
for (int ti=0; ti<Textures.Count(); ti++) {
if (crc == Textures[ti].Crc) {
break;
}
}
if (ti == Textures.Count()) {
TexClass tex;
tex.Map = *map;
tex.Crc = crc;
Textures.Add(tex);
}
return ti;
}
unsigned long W3dMaterialDescClass::Compute_Crc(const W3dVertexMaterialStruct & vmat,
const char *mapper_args0,
const char *mapper_args1)
{
unsigned long crc = 0;
crc = CRC_Memory((const unsigned char *)&vmat.Attributes,sizeof(vmat.Attributes),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Ambient,sizeof(vmat.Ambient),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Diffuse,sizeof(vmat.Diffuse),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Specular,sizeof(vmat.Specular),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Emissive,sizeof(vmat.Emissive),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Shininess,sizeof(vmat.Shininess),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Opacity,sizeof(vmat.Opacity),crc);
crc = CRC_Memory((const unsigned char *)&vmat.Translucency,sizeof(vmat.Translucency),crc);
// Add mapper args string to crc. We are stripping out spaces, tabs, and
// leading/trailing newlines before computing the CRC so two strings will
// only differ if they have visible differences.
crc = Add_String_To_Crc(mapper_args0, crc);
crc = Add_String_To_Crc(mapper_args1, crc);
return crc;
}
unsigned long W3dMaterialDescClass::Compute_Crc(const W3dShaderStruct & shader)
{
unsigned long crc = 0;
crc = CRC_Memory((const unsigned char *)&shader,sizeof(shader),crc);
return crc;
}
unsigned long W3dMaterialDescClass::Compute_Crc(const W3dMapClass & map)
{
unsigned long crc = 0;
if (map.AnimInfo != NULL) {
crc = CRC_Memory((const unsigned char *)&map.AnimInfo->Attributes,sizeof(map.AnimInfo->Attributes),crc);
crc = CRC_Memory((const unsigned char *)&map.AnimInfo->AnimType,sizeof(map.AnimInfo->AnimType),crc);
crc = CRC_Memory((const unsigned char *)&map.AnimInfo->FrameCount,sizeof(map.AnimInfo->FrameCount),crc);
crc = CRC_Memory((const unsigned char *)&map.AnimInfo->FrameRate,sizeof(map.AnimInfo->FrameRate),crc);
}
crc = CRC_Stringi(map.Filename, crc);
return crc;
}
unsigned long W3dMaterialDescClass::Add_String_To_Crc(const char *str, unsigned long in_crc)
{
unsigned long out_crc = in_crc;
if (str) {
int len = strlen(str);
char *temp = new char[len + 1];
const char *p_in = str;
// skip leading spaces, tabs, newlines
for (; *p_in == ' ' || *p_in == '\t' || *p_in == '\r' || *p_in == '\n'; p_in++);
// copy string, skipping spaces and tabs
char * p_out = temp;
int count = 0;
for (; *p_in; p_in++) {
for (; *p_in == ' ' || *p_in == '\t'; p_in++);
if (!(*p_in)) break;
*p_out = *p_in;
p_out++;
count++;
}
*p_out = 0;
// Erase any trailing newlines:
if (count) {
// p_out now points to the ending null - make it point to the
// character before it (the last character of the string proper)
p_out--;
for (; *p_out == '\r' || *p_out == '\n'; p_out--) {
*p_out = '\000';
count--;
}
}
out_crc = CRC_Memory((const unsigned char *)temp,count,in_crc);
delete [] temp;
}
return out_crc;
}
Reference in New Issue View Git Blame Copy Permalink