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

987 lines
No EOL
29 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : WW3D *
* *
* $Archive:: /Commando/Code/ww3d2/vertmaterial.cpp $*
* *
* Author:: Greg Hjelstrom *
* *
* $Modtime:: 2/11/02 9:38a $*
* *
* $Revision:: 43 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* Init -- init code *
* Shutdown -- shutdown code *
* Get_Preset -- retrieve presets *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "vertmaterial.h"
#include "realcrc.h"
#include "wwdebug.h"
#include "w3d_util.h"
#include "chunkio.h"
#include "w3derr.h"
#include "ini.h"
#include "xstraw.h"
#include "dx8wrapper.h"
#include <stdio.h>
#include <string.h>
static unsigned int unique=1;
VertexMaterialClass* VertexMaterialClass::Presets[VertexMaterialClass::PRESET_COUNT];
/*
** VertexMaterialClass Implementation
*/
VertexMaterialClass::VertexMaterialClass(void):
Material(NULL),
Flags(0),
AmbientColorSource(D3DMCS_MATERIAL),
EmissiveColorSource(D3DMCS_MATERIAL),
DiffuseColorSource(D3DMCS_MATERIAL),
UseLighting(false),
UniqueID(0),
CRCDirty(true)
{
int i;
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++)
{
Mapper[i]=NULL;
UVSource[i] = i;
}
Material=new D3DMATERIAL8;
memset(Material,0,sizeof(D3DMATERIAL8));
Set_Ambient(1.0f,1.0f,1.0f);
Set_Diffuse(1.0f,1.0f,1.0f);
Set_Opacity(1.0f);
}
VertexMaterialClass::VertexMaterialClass(const VertexMaterialClass & src) :
Material(NULL),
Flags(src.Flags),
AmbientColorSource(src.AmbientColorSource),
EmissiveColorSource(src.EmissiveColorSource),
DiffuseColorSource(src.DiffuseColorSource),
UseLighting(src.UseLighting),
Name(src.Name),
UniqueID(src.UniqueID),
CRCDirty(true)
{
int i;
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++)
{
Mapper[i]=NULL;
if (src.Mapper[i])
{
TextureMapperClass *mapper=src.Mapper[i]->Clone();
Set_Mapper(mapper,i);
mapper->Release_Ref();
}
UVSource[i] = src.UVSource[i];
}
Material=new D3DMATERIAL8;
memcpy(Material,src.Material,sizeof(D3DMATERIAL8));
}
void VertexMaterialClass::Make_Unique()
{
CRCDirty=true;
UniqueID=unique;
unique++;
}
VertexMaterialClass::~VertexMaterialClass(void)
{
int i;
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++)
{
if (Mapper[i])
{
REF_PTR_RELEASE(Mapper[i]);
Mapper[i]=NULL;
}
}
delete Material;
}
VertexMaterialClass & VertexMaterialClass::operator = (const VertexMaterialClass &src)
{
if (this != &src) {
Name=src.Name;
Flags = src.Flags;
AmbientColorSource = src.AmbientColorSource;
EmissiveColorSource = src.EmissiveColorSource;
DiffuseColorSource = src.DiffuseColorSource;
UseLighting=src.UseLighting;
UniqueID=src.UniqueID;
CRCDirty=src.CRCDirty;
int stage;
for (stage=0;stage<MeshBuilderClass::MAX_STAGES;++stage) {
if (Mapper[stage] != NULL) {
Mapper[stage]->Release_Ref();
Mapper[stage] = NULL;
}
}
for (stage=0;stage<MeshBuilderClass::MAX_STAGES;++stage) {
if (src.Mapper[stage]) {
TextureMapperClass *mapper = src.Mapper[stage]->Clone();
Set_Mapper(mapper,stage);
mapper->Release_Ref();
}
UVSource[stage] = src.UVSource[stage];
}
*Material=*src.Material;
}
return *this;
}
unsigned long VertexMaterialClass::Compute_CRC(void) const
{
unsigned long crc = 0;
// don't include the name when determining whether two vertex materials match
// crc = CRC_Memory(reinterpret_cast<const unsigned char *>(Name.Peek_Buffer()),sizeof(char)*strlen(Name),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(Material),sizeof(D3DMATERIAL8),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&Flags),sizeof(Flags),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&DiffuseColorSource),sizeof(DiffuseColorSource),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&AmbientColorSource),sizeof(AmbientColorSource),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&EmissiveColorSource),sizeof(EmissiveColorSource),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&UVSource),sizeof(UVSource),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&UseLighting),sizeof(UseLighting),crc);
crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&UniqueID),sizeof(UniqueID),crc);
int i;
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++)
{
if (Mapper[i]) crc = CRC_Memory(reinterpret_cast<const unsigned char *>(&(Mapper[i])),sizeof(TextureMapperClass*),crc);
}
return crc;
}
// Ambient Get and Sets
void VertexMaterialClass::Get_Ambient(Vector3 * set) const
{
assert(set);
*set=Vector3(Material->Ambient.r,Material->Ambient.g,Material->Ambient.b);
}
void VertexMaterialClass::Set_Ambient(const Vector3 & color)
{
CRCDirty=true;
Material->Ambient.r=color.X;
Material->Ambient.g=color.Y;
Material->Ambient.b=color.Z;
}
void VertexMaterialClass::Set_Ambient(float r,float g,float b)
{
CRCDirty=true;
Material->Ambient.r=r;
Material->Ambient.g=g;
Material->Ambient.b=b;
}
// Diffuse Get and Sets
void VertexMaterialClass::Get_Diffuse(Vector3 * set) const
{
assert(set);
*set=Vector3(Material->Diffuse.r,Material->Diffuse.g,Material->Diffuse.b);
}
void VertexMaterialClass::Set_Diffuse(const Vector3 & color)
{
CRCDirty=true;
Material->Diffuse.r=color.X;
Material->Diffuse.g=color.Y;
Material->Diffuse.b=color.Z;
}
void VertexMaterialClass::Set_Diffuse(float r,float g,float b)
{
CRCDirty=true;
Material->Diffuse.r=r;
Material->Diffuse.g=g;
Material->Diffuse.b=b;
}
// Specular Get and Sets
void VertexMaterialClass::Get_Specular(Vector3 * set) const
{
assert(set);
*set=Vector3(Material->Specular.r,Material->Specular.g,Material->Specular.b);
}
void VertexMaterialClass::Set_Specular(const Vector3 & color)
{
CRCDirty=true;
Material->Specular.r=color.X;
Material->Specular.g=color.Y;
Material->Specular.b=color.Z;
}
void VertexMaterialClass::Set_Specular(float r,float g,float b)
{
CRCDirty=true;
Material->Specular.r=r;
Material->Specular.g=g;
Material->Specular.b=b;
}
// Emissive Get and Sets
void VertexMaterialClass::Get_Emissive(Vector3 * set) const
{
assert(set);
*set=Vector3(Material->Emissive.r,Material->Emissive.g,Material->Emissive.b);
}
void VertexMaterialClass::Set_Emissive(const Vector3 & color)
{
CRCDirty=true;
Material->Emissive.r=color.X;
Material->Emissive.g=color.Y;
Material->Emissive.b=color.Z;
}
void VertexMaterialClass::Set_Emissive(float r,float g,float b)
{
CRCDirty=true;
Material->Emissive.r=r;
Material->Emissive.g=g;
Material->Emissive.b=b;
}
float VertexMaterialClass::Get_Shininess(void) const
{
return Material->Power;
}
void VertexMaterialClass::Set_Shininess(float shin)
{
CRCDirty=true;
Material->Power=shin;
}
float VertexMaterialClass::Get_Opacity(void) const
{
return Material->Diffuse.a;
}
void VertexMaterialClass::Set_Opacity(float o)
{
CRCDirty=true;
Material->Diffuse.a=o;
}
void VertexMaterialClass::Set_Ambient_Color_Source(ColorSourceType src)
{
CRCDirty=true;
switch (src)
{
case COLOR1: AmbientColorSource = D3DMCS_COLOR1; break;
case COLOR2: AmbientColorSource = D3DMCS_COLOR2; break;
default: AmbientColorSource = D3DMCS_MATERIAL; break;
}
}
void VertexMaterialClass::Set_Emissive_Color_Source(ColorSourceType src)
{
CRCDirty=true;
switch (src)
{
case COLOR1: EmissiveColorSource = D3DMCS_COLOR1; break;
case COLOR2: EmissiveColorSource = D3DMCS_COLOR2; break;
default: EmissiveColorSource = D3DMCS_MATERIAL; break;
}
}
void VertexMaterialClass::Set_Diffuse_Color_Source(ColorSourceType src)
{
CRCDirty=true;
switch (src)
{
case COLOR1: DiffuseColorSource = D3DMCS_COLOR1; break;
case COLOR2: DiffuseColorSource = D3DMCS_COLOR2; break;
default: DiffuseColorSource = D3DMCS_MATERIAL; break;
}
}
VertexMaterialClass::ColorSourceType
VertexMaterialClass::Get_Ambient_Color_Source(void)
{
switch(AmbientColorSource)
{
case D3DMCS_COLOR1: return COLOR1;
case D3DMCS_COLOR2: return COLOR2;
default: return MATERIAL;
}
}
VertexMaterialClass::ColorSourceType
VertexMaterialClass::Get_Emissive_Color_Source(void)
{
switch(EmissiveColorSource)
{
case D3DMCS_COLOR1: return COLOR1;
case D3DMCS_COLOR2: return COLOR2;
default: return MATERIAL;
}
}
VertexMaterialClass::ColorSourceType
VertexMaterialClass::Get_Diffuse_Color_Source(void)
{
switch(DiffuseColorSource)
{
case D3DMCS_COLOR1: return COLOR1;
case D3DMCS_COLOR2: return COLOR2;
default: return MATERIAL;
}
}
void VertexMaterialClass::Set_UV_Source(int stage,int array_index)
{
WWASSERT(stage >= 0);
WWASSERT(stage < MeshBuilderClass::MAX_STAGES);
WWASSERT(array_index >= 0);
WWASSERT(array_index < 8);
CRCDirty=true;
UVSource[stage] = array_index;
}
int VertexMaterialClass::Get_UV_Source(int stage)
{
WWASSERT(stage >= 0);
WWASSERT(stage < MeshBuilderClass::MAX_STAGES);
return UVSource[stage];
}
void VertexMaterialClass::Init_From_Material3(const W3dMaterial3Struct & mat3)
{
Vector3 tmp0,tmp1,tmp2;
W3dUtilityClass::Convert_Color(mat3.DiffuseColor,&tmp0);
W3dUtilityClass::Convert_Color(mat3.DiffuseCoefficients,&tmp1);
tmp2.X = tmp0.X * tmp1.X;
tmp2.Y = tmp0.Y * tmp1.Y;
tmp2.Z = tmp0.Z * tmp1.Z;
Set_Diffuse(tmp2);
W3dUtilityClass::Convert_Color(mat3.SpecularColor,&tmp0);
W3dUtilityClass::Convert_Color(mat3.SpecularCoefficients,&tmp1);
tmp2.X = tmp0.X * tmp1.X;
tmp2.Y = tmp0.Y * tmp1.Y;
tmp2.Z = tmp0.Z * tmp1.Z;
Set_Specular(tmp2);
W3dUtilityClass::Convert_Color(mat3.EmissiveCoefficients,&tmp0);
Set_Emissive(tmp0);
W3dUtilityClass::Convert_Color(mat3.AmbientCoefficients,&tmp0);
Set_Ambient(tmp0);
Set_Shininess(mat3.Shininess);
Set_Opacity(mat3.Opacity);
}
WW3DErrorType VertexMaterialClass::Load_W3D(ChunkLoadClass & cload)
{
char name[256];
W3dVertexMaterialStruct vmat;
bool hasname = false;
char *mapping0_arg_buffer = NULL;
char *mapping1_arg_buffer = NULL;
unsigned int mapping0_arg_len = 0U;
unsigned int mapping1_arg_len = 0U;
while (cload.Open_Chunk()) {
switch (cload.Cur_Chunk_ID()) {
case W3D_CHUNK_VERTEX_MATERIAL_NAME:
cload.Read(&name,cload.Cur_Chunk_Length());
hasname = true;
break;
case W3D_CHUNK_VERTEX_MATERIAL_INFO:
if (cload.Read(&vmat,sizeof(vmat)) != sizeof(vmat)) {
return WW3D_ERROR_LOAD_FAILED;
}
break;
case W3D_CHUNK_VERTEX_MAPPER_ARGS0:
mapping0_arg_len = cload.Cur_Chunk_Length();
mapping0_arg_buffer = new char[mapping0_arg_len];
if (cload.Read(mapping0_arg_buffer, mapping0_arg_len) != mapping0_arg_len) {
return WW3D_ERROR_LOAD_FAILED;
}
break;
case W3D_CHUNK_VERTEX_MAPPER_ARGS1:
mapping1_arg_len = cload.Cur_Chunk_Length();
mapping1_arg_buffer = new char[mapping1_arg_len];
if (cload.Read(mapping1_arg_buffer, mapping1_arg_len) != mapping1_arg_len) {
return WW3D_ERROR_LOAD_FAILED;
}
break;
};
cload.Close_Chunk();
}
if (hasname) {
Set_Name(name);
}
// Read an INIClass from the mapping argument buffer - this will be used
// to initialize any special mappers used.
INIClass mapping0_arg_ini;
if (mapping0_arg_buffer) {
char *extended_arg_buffer = new char[mapping0_arg_len + 10];
sprintf(extended_arg_buffer, "[Args]\n%s", mapping0_arg_buffer);
mapping0_arg_len = strlen(extended_arg_buffer) + 1;
delete [] mapping0_arg_buffer;
mapping0_arg_buffer = NULL;
BufferStraw map_arg_buf_straw((void *)extended_arg_buffer, mapping0_arg_len);
mapping0_arg_ini.Load(map_arg_buf_straw);
delete [] extended_arg_buffer;
extended_arg_buffer = NULL;
}
INIClass mapping1_arg_ini;
if (mapping1_arg_buffer) {
char *extended_arg_buffer = new char[mapping1_arg_len + 20];
sprintf(extended_arg_buffer, "[Args]\n%s", mapping1_arg_buffer);
mapping1_arg_len = strlen(extended_arg_buffer) + 1;
delete [] mapping1_arg_buffer;
mapping1_arg_buffer = NULL;
BufferStraw map_arg_buf_straw((void *)extended_arg_buffer, mapping1_arg_len);
mapping1_arg_ini.Load(map_arg_buf_straw);
delete [] extended_arg_buffer;
extended_arg_buffer = NULL;
}
if (vmat.Attributes & W3DVERTMAT_USE_DEPTH_CUE) {
Set_Flag(VertexMaterialClass::DEPTH_CUE,true);
}
if (vmat.Attributes & W3DVERTMAT_COPY_SPECULAR_TO_DIFFUSE) {
Set_Flag(VertexMaterialClass::COPY_SPECULAR_TO_DIFFUSE,true);
}
// Set up the vertex mapper. If it is one of the simple
// ones, set the pointer to one of the global instances.
int mapping = vmat.Attributes & W3DVERTMAT_STAGE0_MAPPING_MASK;
switch(mapping) {
case W3DVERTMAT_STAGE0_MAPPING_UV:
break;
case W3DVERTMAT_STAGE0_MAPPING_ENVIRONMENT:
{
EnvironmentMapperClass *mapper = NEW_REF(EnvironmentMapperClass,(0));
Set_Mapper(mapper);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_CHEAP_ENVIRONMENT:
{
ClassicEnvironmentMapperClass *mapper = NEW_REF(ClassicEnvironmentMapperClass,(0));
Set_Mapper(mapper);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_LINEAR_OFFSET:
{
LinearOffsetTextureMapperClass *mapper =
NEW_REF(LinearOffsetTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_SCREEN:
{
ScreenMapperClass *mapper =
NEW_REF(ScreenMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_SCALE:
{
ScaleTextureMapperClass *mapper =
NEW_REF(ScaleTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_GRID:
{
GridTextureMapperClass *mapper =
NEW_REF(GridTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_ROTATE:
{
RotateTextureMapperClass *mapper =
NEW_REF(RotateTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_SINE_LINEAR_OFFSET:
{
SineLinearOffsetTextureMapperClass *mapper =
NEW_REF(SineLinearOffsetTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_STEP_LINEAR_OFFSET:
{
StepLinearOffsetTextureMapperClass *mapper =
NEW_REF(StepLinearOffsetTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_ZIGZAG_LINEAR_OFFSET:
{
ZigZagLinearOffsetTextureMapperClass *mapper =
NEW_REF(ZigZagLinearOffsetTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_WS_CLASSIC_ENV:
{
WSClassicEnvironmentMapperClass *mapper = NEW_REF(WSClassicEnvironmentMapperClass,(0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_WS_ENVIRONMENT:
{
WSEnvironmentMapperClass *mapper = NEW_REF(WSEnvironmentMapperClass,(0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_GRID_CLASSIC_ENV:
{
GridClassicEnvironmentMapperClass *mapper =
NEW_REF(GridClassicEnvironmentMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_GRID_ENVIRONMENT:
{
GridEnvironmentMapperClass *mapper =
NEW_REF(GridEnvironmentMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_RANDOM:
{
RandomTextureMapperClass *mapper =
NEW_REF(RandomTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_EDGE:
{
EdgeMapperClass *mapper =
NEW_REF(EdgeMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE0_MAPPING_BUMPENV:
{
BumpEnvTextureMapperClass *mapper =
NEW_REF(BumpEnvTextureMapperClass,(mapping0_arg_ini, "Args", 0));
Set_Mapper(mapper,0);
mapper->Release_Ref();
}
break;
default:
WWDEBUG_SAY(("Unsupported mapper in %s\n",name));
break;
}
// Same setup for stage 1's mapper.
mapping = vmat.Attributes & W3DVERTMAT_STAGE1_MAPPING_MASK;
switch(mapping) {
case W3DVERTMAT_STAGE1_MAPPING_UV:
break;
case W3DVERTMAT_STAGE1_MAPPING_ENVIRONMENT:
{
EnvironmentMapperClass *mapper = new EnvironmentMapperClass(1);
Set_Mapper(mapper, 1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_CHEAP_ENVIRONMENT:
{
ClassicEnvironmentMapperClass *mapper = new ClassicEnvironmentMapperClass(1);
Set_Mapper(mapper, 1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_LINEAR_OFFSET:
{
LinearOffsetTextureMapperClass *mapper =
new LinearOffsetTextureMapperClass(mapping1_arg_ini, "Args", 1);
Set_Mapper(mapper, 1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_SCREEN:
{
ScreenMapperClass *mapper =
new ScreenMapperClass(mapping1_arg_ini, "Args", 1);
Set_Mapper(mapper, 1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_SCALE:
{
ScaleTextureMapperClass *mapper =
NEW_REF(ScaleTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_GRID:
{
GridTextureMapperClass *mapper =
NEW_REF(GridTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_ROTATE:
{
RotateTextureMapperClass *mapper =
NEW_REF(RotateTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_SINE_LINEAR_OFFSET:
{
SineLinearOffsetTextureMapperClass *mapper =
NEW_REF(SineLinearOffsetTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_STEP_LINEAR_OFFSET:
{
StepLinearOffsetTextureMapperClass *mapper =
NEW_REF(StepLinearOffsetTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_ZIGZAG_LINEAR_OFFSET:
{
ZigZagLinearOffsetTextureMapperClass *mapper =
NEW_REF(ZigZagLinearOffsetTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_WS_CLASSIC_ENV:
{
WSClassicEnvironmentMapperClass *mapper = NEW_REF(WSClassicEnvironmentMapperClass,(1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_WS_ENVIRONMENT:
{
WSEnvironmentMapperClass *mapper = NEW_REF(WSEnvironmentMapperClass,(1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_GRID_CLASSIC_ENV:
{
GridClassicEnvironmentMapperClass *mapper =
NEW_REF(GridClassicEnvironmentMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_GRID_ENVIRONMENT:
{
GridEnvironmentMapperClass *mapper =
NEW_REF(GridEnvironmentMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_RANDOM:
{
RandomTextureMapperClass *mapper =
NEW_REF(RandomTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_EDGE:
{
EdgeMapperClass *mapper =
NEW_REF(EdgeMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
case W3DVERTMAT_STAGE1_MAPPING_BUMPENV:
{
BumpEnvTextureMapperClass *mapper =
NEW_REF(BumpEnvTextureMapperClass,(mapping1_arg_ini, "Args", 1));
Set_Mapper(mapper,1);
mapper->Release_Ref();
}
break;
default:
WWDEBUG_SAY(("Unsupported mapper in %s\n",name));
break;
}
Vector3 tmp;
W3dUtilityClass::Convert_Color(vmat.Ambient,&tmp);
Set_Ambient(tmp);
W3dUtilityClass::Convert_Color(vmat.Diffuse,&tmp);
Set_Diffuse(tmp);
W3dUtilityClass::Convert_Color(vmat.Specular,&tmp);
Set_Specular(tmp);
W3dUtilityClass::Convert_Color(vmat.Emissive,&tmp);
Set_Emissive(tmp);
Set_Shininess(vmat.Shininess);
Set_Opacity(vmat.Opacity);
return WW3D_ERROR_OK;
}
WW3DErrorType VertexMaterialClass::Save_W3D(ChunkSaveClass & csave)
{
WWASSERT(0);
return WW3D_ERROR_OK;
}
void VertexMaterialClass::Apply(void) const
{
int i;
DX8Wrapper::Set_DX8_Material(Material);
DX8Wrapper::Set_DX8_Render_State(D3DRS_LIGHTING,UseLighting);
DX8Wrapper::Set_DX8_Render_State(D3DRS_AMBIENTMATERIALSOURCE,AmbientColorSource);
DX8Wrapper::Set_DX8_Render_State(D3DRS_DIFFUSEMATERIALSOURCE,DiffuseColorSource);
DX8Wrapper::Set_DX8_Render_State(D3DRS_EMISSIVEMATERIALSOURCE,EmissiveColorSource);
// set to default values if no mappers
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++) {
if (Mapper[i]) {
Mapper[i]->Apply(UVSource[i]);
} else {
DX8Wrapper::Set_DX8_Texture_Stage_State(i,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_PASSTHRU | UVSource[i]);
DX8Wrapper::Set_DX8_Texture_Stage_State(i,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE);
}
}
}
void VertexMaterialClass::Apply_Null(void)
{
int i;
static D3DMATERIAL8 default_settings =
{
{ 1.0f, 1.0f, 1.0f, 1.0f }, // diffuse
{ 1.0f, 1.0f, 1.0f, 1.0f }, // ambient
{ 0.0f, 0.0f, 0.0f, 0.0f }, // specular
{ 0.0f, 0.0f, 0.0f, 0.0f }, // emissive
1.0f // power
};
DX8Wrapper::Set_DX8_Render_State(D3DRS_LIGHTING,FALSE);
DX8Wrapper::Set_DX8_Material(&default_settings);
DX8Wrapper::Set_DX8_Render_State(D3DRS_AMBIENTMATERIALSOURCE,D3DMCS_MATERIAL);
DX8Wrapper::Set_DX8_Render_State(D3DRS_DIFFUSEMATERIALSOURCE,D3DMCS_MATERIAL);
DX8Wrapper::Set_DX8_Render_State(D3DRS_EMISSIVEMATERIALSOURCE,D3DMCS_MATERIAL);
// set to default values if no mappers
for (i=0; i<MeshBuilderClass::MAX_STAGES; i++) {
DX8Wrapper::Set_DX8_Texture_Stage_State(i,D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_PASSTHRU | i);
DX8Wrapper::Set_DX8_Texture_Stage_State(i,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE);
}
}
/***********************************************************************************************
* Init -- init code *
* *
* *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 2/14/2001 hy : Created. *
*=============================================================================================*/
void VertexMaterialClass::Init()
{
int i;
for (i=0; i<PRESET_COUNT;i++)
Presets[i]=NEW_REF(VertexMaterialClass,());
// Set up presets
Presets[PRELIT_DIFFUSE]->Set_Diffuse_Color_Source(VertexMaterialClass::COLOR1);
Presets[PRELIT_DIFFUSE]->Set_Lighting(false);
Presets[PRELIT_NODIFFUSE]->Set_Lighting(false);
}
/***********************************************************************************************
* Shutdown -- shutdown code *
* *
* *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 2/14/2001 hy : Created. *
*=============================================================================================*/
void VertexMaterialClass::Shutdown()
{
int i;
for (i=0; i<PRESET_COUNT;i++)
REF_PTR_RELEASE(Presets[i]);
}
/***********************************************************************************************
* Get_Preset -- retrieve presets *
* *
* *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 2/14/2001 hy : Created. *
*=============================================================================================*/
VertexMaterialClass * VertexMaterialClass::Get_Preset(PresetType type)
{
WWASSERT(type<PRESET_COUNT);
Presets[type]->Add_Ref();
return Presets[type];
}
Reference in a new issue View git blame Copy permalink