Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
2140 lines
48 KiB
C++
2140 lines
48 KiB
C++
#include "MAXProxyHeaders.hpp"
|
|
#include <ElementRenderer\StateChange.hpp>
|
|
|
|
//
|
|
//############################################################################
|
|
//############################ MAXState ##############################
|
|
//############################################################################
|
|
//
|
|
|
|
MemoryBlock*
|
|
MAXState::AllocatedMemory = NULL;
|
|
MAXState::ClassData*
|
|
MAXState::DefaultData = NULL;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::InitializeClass()
|
|
{
|
|
Verify(!AllocatedMemory);
|
|
AllocatedMemory =
|
|
new MemoryBlock(
|
|
sizeof(MAXState),
|
|
80,
|
|
10,
|
|
"MAXState"
|
|
);
|
|
Register_Object(AllocatedMemory);
|
|
|
|
Verify(!DefaultData);
|
|
DefaultData =
|
|
new ClassData(
|
|
MAXStateClassID,
|
|
"MAXState",
|
|
StateProxy::DefaultData
|
|
);
|
|
Register_Object(DefaultData);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::TerminateClass()
|
|
{
|
|
Unregister_Object(DefaultData);
|
|
delete DefaultData;
|
|
DefaultData = NULL;
|
|
|
|
Unregister_Object(AllocatedMemory);
|
|
delete AllocatedMemory;
|
|
AllocatedMemory = NULL;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::Destroy()
|
|
{
|
|
Check_Object(this);
|
|
Verify(referenceCount == 1);
|
|
STOP(("Not implemented"));
|
|
DetachReference();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MAXState::MAXState(
|
|
MAXStateLibrary *library,
|
|
INode *mesh,
|
|
Mtl *material,
|
|
BitmapTex *texture,
|
|
int indice
|
|
):
|
|
StateProxy(DefaultData, library),
|
|
meshState(mesh),
|
|
materialState(material),
|
|
textureState(texture),
|
|
mapIndice(indice)
|
|
{
|
|
Check_Pointer(this);
|
|
Check_Object(this);
|
|
bAlphaMode = false;
|
|
bFlatShaded = false;
|
|
matID = 0;
|
|
mipmapHint=0;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MAXState::~MAXState()
|
|
{
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::TestInstance() const
|
|
{
|
|
Verify(IsDerivedFrom(DefaultData));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetName(MString *name)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(name);
|
|
name->AllocateLength(0);
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetName(const char* name)
|
|
{
|
|
Check_Object(this);
|
|
Check_Pointer(name);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetSpecularColor(RGBColor *color)
|
|
{
|
|
return false;
|
|
// Not implemented in MLRSTate
|
|
Check_Object(this);
|
|
Check_Pointer(color);
|
|
if (materialState)
|
|
{
|
|
Check_Pointer(materialState);
|
|
Color matcolor = materialState->GetSpecular();
|
|
color->red = matcolor.r;
|
|
color->green = matcolor.g;
|
|
color->blue = matcolor.b;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetSpecularColor(const RGBColor &color)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(&color);
|
|
|
|
Check_Pointer(materialState);
|
|
Color matcolor;
|
|
matcolor.r = color.red;
|
|
matcolor.g = color.green;
|
|
matcolor.b = color.blue;
|
|
// TODO: What about animated textures?
|
|
materialState->SetSpecular(matcolor,0);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Scalar
|
|
MAXState::GetSpecularShininess()
|
|
{
|
|
Check_Object(this);
|
|
if (materialState)
|
|
{
|
|
Check_Pointer(materialState);
|
|
return materialState->GetShininess();
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetSpecularShininess(Scalar shininess)
|
|
{
|
|
Check_Object(this);
|
|
Check_Pointer(materialState);
|
|
materialState->SetShininess(shininess,0);
|
|
STOP(("SetSpecularShininess not implemented"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetSpecular(bool *bval)
|
|
{
|
|
Check_Object(this);
|
|
if (materialState)
|
|
{
|
|
Check_Pointer(materialState);
|
|
if (materialState->SubTexmapOn(ID_SP))
|
|
{
|
|
*bval = true;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetSpecular(bool)
|
|
{
|
|
Check_Object(this);
|
|
// Needs to set the texmap flag to on
|
|
//STOP(("SetSpecular not implemented"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetSpecularChildPermission()
|
|
{
|
|
Check_Object(this);
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetSpecularChildPermission(bool override)
|
|
{
|
|
Check_Object(this);
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
// this routine was done the hard way because it is a quick hack to include
|
|
// multi - texture. It will be rewritten when the God's above decide how
|
|
// multi - texture will be implemented and used - BDB
|
|
//
|
|
bool
|
|
MAXState::GetAlpha(Proxies::StateProxy::AlphaMode *alpha_mode)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == materialState)
|
|
return false;
|
|
|
|
if (0==mipmapHint)
|
|
{
|
|
mipmapHint=1;
|
|
char *name = materialState->GetName();
|
|
|
|
MAXStateLibrary *max_states = GetStateLibrary();
|
|
Check_Object(max_states);
|
|
MAXScene *scene = max_states->GetSceneProxy();
|
|
|
|
Page *page = scene->FindHint(name);
|
|
if (page)
|
|
{
|
|
const char *entry;
|
|
if (page->GetEntry("MipMap",&entry))
|
|
{
|
|
if (strnicmp(entry,"None",4)==0)
|
|
{
|
|
mipmapHint++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mipmapHint)
|
|
{
|
|
if (mipmapHint>1)
|
|
{
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::OneZeroMode;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Check_Pointer(materialState);
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::OneOneMode;
|
|
if (bAlphaMode || materialState->SubTexmapOn(ID_OP))
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::AlphaOneMode;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
if ((Cast_Pointer(StdMat*, sub)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::OneOneMode;
|
|
if (bAlphaMode || materialState->SubTexmapOn(ID_OP))
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::AlphaOneMode;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (bAlphaMode || materialState->SubTexmapOn(ID_OP))
|
|
{
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::AlphaInvAlphaMode;
|
|
return true;
|
|
}
|
|
*alpha_mode = Proxies::StateProxy::AlphaMode::OneZeroMode;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetAlpha(Proxies::StateProxy::AlphaMode alpha)
|
|
{
|
|
Check_Object(this);
|
|
Check_Pointer(materialState);
|
|
switch (alpha)
|
|
{
|
|
case Proxies::StateProxy::AlphaMode::OneOneMode:
|
|
{
|
|
// Set the material to additive
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
int x=1;
|
|
}
|
|
Cast_Pointer(StdMat*, materialState)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
Cast_Pointer(StdMat*, sub)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Proxies::StateProxy::AlphaMode::OneZeroMode:
|
|
{
|
|
//Check_Pointer(textureState);
|
|
// Set to texture to AlphaNone
|
|
//textureState->SetAlphaSource(ALPHA_NONE);
|
|
break;
|
|
}
|
|
case Proxies::StateProxy::AlphaMode::AlphaInvAlphaMode:
|
|
case Proxies::StateProxy::AlphaMode::KeyedAlphaMode:
|
|
{
|
|
bAlphaMode = true;
|
|
|
|
//Check_Pointer(materialState);
|
|
Texmap *tex = materialState->GetSubTexmap(ID_DI);
|
|
|
|
if (tex && tex->ClassID() == Class_ID(BMTEX_CLASS_ID,0))
|
|
{
|
|
BitmapTex *bmtex = (BitmapTex*)tex;
|
|
bmtex->SetAlphaAsMono(true);
|
|
bmtex->SetAlphaSource(ALPHA_NONE);
|
|
}
|
|
materialState->SetSubTexmap(ID_OP,tex);
|
|
/* materialState->EnableMap(ID_OP, TRUE);
|
|
materialState->SetTexmapAmt(ID_OP, 1.f, 0);*/
|
|
break;
|
|
}
|
|
default:
|
|
STOP(("SetAlpha, mode not supported"));
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetAlphaChildPermission()
|
|
{
|
|
Check_Object(this);
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetAlphaChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFilter(FilterMode *filter_mode)
|
|
{
|
|
Check_Object(this);
|
|
if (materialState)
|
|
{
|
|
Check_Pointer(materialState);
|
|
// TODO: What about multi-texture???
|
|
Texmap *texmap = materialState->GetSubTexmap(ID_DI);
|
|
if (texmap)
|
|
{
|
|
Check_Pointer(texmap);
|
|
if (texmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0))
|
|
{
|
|
switch ( ((BitmapTex*)texmap)->GetFilterType())
|
|
{
|
|
case FILTER_PYR:
|
|
{
|
|
*filter_mode = Proxies::StateProxy::FilterMode::TriLinearFilterMode;
|
|
break;
|
|
}
|
|
case FILTER_SAT:
|
|
{
|
|
*filter_mode = Proxies::StateProxy::FilterMode::BiLinearFilterMode;
|
|
break;
|
|
}
|
|
case FILTER_NADA:
|
|
{
|
|
*filter_mode = Proxies::StateProxy::FilterMode::NoFilterMode;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
STOP(("Invalid Filter Type"));
|
|
}
|
|
}
|
|
|
|
// Should let always let decide filter type
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFilter(FilterMode mode)
|
|
{
|
|
Check_Object(this);
|
|
Check_Pointer(materialState);
|
|
// TODO: What about multi-texture???
|
|
Texmap *texmap = materialState->GetSubTexmap(ID_DI);
|
|
if (texmap)
|
|
{
|
|
Check_Pointer(texmap);
|
|
if (texmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0))
|
|
{
|
|
int filter = 0;
|
|
switch ( mode)
|
|
{
|
|
case Proxies::StateProxy::FilterMode::TriLinearFilterMode:
|
|
{
|
|
filter = FILTER_PYR;
|
|
break;
|
|
}
|
|
case Proxies::StateProxy::FilterMode::BiLinearFilterMode:
|
|
{
|
|
filter = FILTER_SAT;
|
|
break;
|
|
}
|
|
case Proxies::StateProxy::FilterMode::NoFilterMode:
|
|
{
|
|
filter = FILTER_NADA;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
STOP(("Invalid Filter Type"));
|
|
}
|
|
}
|
|
((BitmapTex*)texmap)->SetFilterType(filter);
|
|
}
|
|
else
|
|
{
|
|
STOP(("SetFilter: Diffuse Material map must have a bitmap texture"));
|
|
}
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFilterChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFilterChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFog(FogMode *fog_on)
|
|
{
|
|
Check_Object(this);
|
|
//
|
|
// Art is using self-illumination to prevent lighting, and this automatically turns on fog
|
|
// they want to have the option of turning it off explicitely so we are checking for this first
|
|
//
|
|
// While I'm here I will enable all the values
|
|
//
|
|
if (meshState)
|
|
{
|
|
Check_Pointer(meshState);
|
|
char *name = meshState->GetName();
|
|
TSTR value;
|
|
TSTR key="FOGMODESETTING";
|
|
if (meshState->GetUserPropString(key,value))
|
|
{
|
|
bool bValid = false;
|
|
if ('0' == value[0])
|
|
{
|
|
*fog_on = DisableFogMode;
|
|
bValid = true;
|
|
}
|
|
if ('1' == value[0])
|
|
{
|
|
*fog_on = GeneralFogMode;
|
|
bValid = true;
|
|
}
|
|
if ('2' == value[0])
|
|
{
|
|
*fog_on = LightFogMode;
|
|
bValid = true;
|
|
}
|
|
if ('3' == value[0])
|
|
{
|
|
*fog_on = CustomFogMode;
|
|
bValid = true;
|
|
}
|
|
if (bValid)
|
|
return true;
|
|
}
|
|
}
|
|
if (materialState)
|
|
{
|
|
float fval = materialState->GetSelfIllum(0);
|
|
if (fval > 0.0f)
|
|
{
|
|
*fog_on = LightFogMode;
|
|
return true;
|
|
}
|
|
// Check that Self-Illumination is checked
|
|
|
|
// float fval = 0.0f;
|
|
// if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
// {
|
|
// fval = Cast_Pointer(StdMat*, materialState)->GetTexmapAmt(ID_SI,0);
|
|
// }
|
|
//
|
|
// if (/*materialState->SubTexmapOn(ID_SI) || */fval > 0.0f)
|
|
//
|
|
// //if (materialState->SubTexmapOn(ID_SI))
|
|
// {
|
|
// *fog_on = LightFogMode;
|
|
// return true;
|
|
// }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFog(FogMode mode)
|
|
{
|
|
/* STOP(("Not Implemented"));
|
|
Check_Object(this);
|
|
Check_Pointer(materialState);
|
|
if (LightFogMode == mode)
|
|
{
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
int x=1;
|
|
}
|
|
Cast_Pointer(StdMat*, materialState)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
|
|
Cast_Pointer(StdMat*, sub)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFogChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFogChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetDither(bool *dither_on)
|
|
{
|
|
return false;
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetDither(bool)
|
|
{
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetDitherChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetDitherChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetTextureCorrection(bool *correction_on)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetTextureCorrection(bool)
|
|
{
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetTextureCorrectionChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetTextureCorrectionChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetTextureWrap(TextureWrapMode* mode)
|
|
{
|
|
Check_Object(this);
|
|
if (materialState)
|
|
{
|
|
Check_Pointer(materialState);
|
|
Texmap *texmap = materialState->GetSubTexmap(ID_DI);
|
|
if (texmap)
|
|
{
|
|
Check_Pointer(texmap);
|
|
UVGen *gen = texmap->GetTheUVGen();
|
|
if (gen)
|
|
{
|
|
Check_Pointer(gen);
|
|
int tiling = gen->GetTextureTiling();
|
|
if ((tiling & U_WRAP) && (tiling & V_WRAP))
|
|
{
|
|
*mode = TextureWrap;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
*mode = TextureClamp;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetTextureWrap(TextureWrapMode)
|
|
{
|
|
Check_Object(this);
|
|
// TODO: does import need this?
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetTextureWrapChildPermission()
|
|
{
|
|
Check_Object(this);
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetTextureWrapChildPermission(bool override)
|
|
{
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetWireFrame(WireFrameMode *wireframe_mode)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == materialState)
|
|
return false;
|
|
Check_Pointer(materialState);
|
|
ULONG mat_requirements = materialState->Requirements(-1);
|
|
|
|
if (mat_requirements & MTLREQ_WIRE)
|
|
{
|
|
*wireframe_mode = Proxies::StateProxy::WireFrameMode::WireFrameOnlyMode;
|
|
}
|
|
else
|
|
{
|
|
*wireframe_mode = Proxies::StateProxy::WireFrameMode::WireFrameOffMode;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetWireFrame(WireFrameMode mode)
|
|
{
|
|
Check_Object(this);
|
|
Check_Pointer(materialState);
|
|
//if (LightFogMode == mode)
|
|
{
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
Cast_Pointer(StdMat*, materialState)->SetWire(Proxies::StateProxy::WireFrameMode::WireFrameOnlyMode == mode?true:false);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
|
|
Cast_Pointer(StdMat*, sub)->SetWire(Proxies::StateProxy::WireFrameMode::WireFrameOnlyMode == mode?true:false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetWireFrameChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetWireFrameChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetZBufferCompare(bool *z_compare)
|
|
{
|
|
Check_Object(this);
|
|
if (meshState)
|
|
{
|
|
Check_Pointer(meshState);
|
|
char *name = meshState->GetName();
|
|
TSTR value;
|
|
TSTR key="ZBUFFERCOMPARE";
|
|
if (meshState->GetUserPropString(key,value))
|
|
{
|
|
bool bValid = false;
|
|
if ('1' == value[0])
|
|
{
|
|
*z_compare = true;
|
|
bValid = true;
|
|
}
|
|
if ('0' == value[0])
|
|
{
|
|
*z_compare = false;
|
|
bValid = true;
|
|
}
|
|
if (bValid)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
*z_compare = true;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetZBufferCompare(bool)
|
|
{
|
|
Check_Object(this);
|
|
//STOP(("SetZBufferCompare Not implemented"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetZBufferCompareChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetZBufferCompareChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetZBufferWrite(bool *z_write)
|
|
{
|
|
Check_Object(this);
|
|
if (meshState)
|
|
{
|
|
Check_Pointer(meshState);
|
|
char *name = meshState->GetName();
|
|
TSTR value;
|
|
TSTR key="ZBUFFERWRITE";
|
|
if (meshState->GetUserPropString(key,value))
|
|
{
|
|
bool bValid = false;
|
|
if ('1' == value[0])
|
|
{
|
|
*z_write = true;
|
|
bValid = true;
|
|
}
|
|
if ('0' == value[0])
|
|
{
|
|
*z_write = false;
|
|
bValid = true;
|
|
}
|
|
if (bValid)
|
|
return true;
|
|
}
|
|
}
|
|
if (NULL == materialState)
|
|
return false;
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*z_write = false;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
if ((Cast_Pointer(StdMat*, sub)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*z_write = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
*z_write = true;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetZBufferWrite(bool)
|
|
{
|
|
Check_Object(this);
|
|
//STOP(("SetZBufferWrite Not implemented"));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetZBufferWriteChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetZBufferWriteChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFlatColoring(bool *flat)
|
|
{
|
|
Check_Object(this);
|
|
*flat = bFlatShaded;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFlatColoring(bool flat)
|
|
{
|
|
bFlatShaded = flat;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetFlatColoringChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetFlatColoringChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetMatTwoSided(bool *onOff)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == materialState)
|
|
return false;
|
|
Check_Pointer(materialState);
|
|
ULONG mat_requirements = materialState->Requirements(-1);
|
|
|
|
*onOff = (mat_requirements & MTLREQ_2SIDE)?true:false;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetMatTwoSided(bool onOff)
|
|
{
|
|
Check_Object(this);
|
|
if (onOff)
|
|
{
|
|
Check_Pointer(materialState);
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
Cast_Pointer(StdMat*, materialState)->SetTwoSided(true);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
Cast_Pointer(StdMat*, sub)->SetTwoSided(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetMatTwoSidedChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetMatTwoSidedChildPermission(bool override)
|
|
{
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetBackface(bool *onOff)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == meshState)
|
|
return false;
|
|
Check_Pointer(meshState);
|
|
|
|
*onOff = meshState->GetBackCull()?true:false;
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetBackface(bool onOff)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == meshState)
|
|
return;
|
|
Check_Pointer(meshState);
|
|
|
|
meshState->BackCull(onOff);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetBackfaceChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetBackfaceChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetPriority(int *priority)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == materialState)
|
|
return false;
|
|
Check_Pointer(materialState);
|
|
|
|
if (meshState)
|
|
{
|
|
Check_Pointer(meshState);
|
|
char *name = meshState->GetName();
|
|
TSTR value;
|
|
TSTR key="PRIORITY";
|
|
if (meshState->GetUserPropString(key,value))
|
|
{
|
|
bool bValid = false;
|
|
if (0==stricmp(value,"CagePriority"))
|
|
{
|
|
*priority = Proxies::StateProxy::CagePriority;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"CageDashPriority"))
|
|
{
|
|
*priority = Proxies::StateProxy::CageEffectsPriority;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"CageEffectsPriority"))
|
|
{
|
|
*priority = Proxies::StateProxy::FlarePriority;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"HUDPriority0"))
|
|
{
|
|
*priority = Proxies::StateProxy::HUDPriority0;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"HUDPriority1"))
|
|
{
|
|
*priority = Proxies::StateProxy::HUDPriority1;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"HUDPriority2"))
|
|
{
|
|
*priority = Proxies::StateProxy::HUDPriority2;
|
|
bValid = true;
|
|
}
|
|
else if (0==stricmp(value,"HUDPriority3"))
|
|
{
|
|
*priority = Proxies::StateProxy::HUDPriority3;
|
|
bValid = true;
|
|
}
|
|
|
|
if (bValid)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (0==mipmapHint)
|
|
{
|
|
mipmapHint=1;
|
|
char *name = materialState->GetName();
|
|
|
|
MAXStateLibrary *max_states = GetStateLibrary();
|
|
Check_Object(max_states);
|
|
MAXScene *scene = max_states->GetSceneProxy();
|
|
|
|
Page *page = scene->FindHint(name);
|
|
if (page)
|
|
{
|
|
const char *entry;
|
|
if (page->GetEntry("MipMap",&entry))
|
|
{
|
|
if (strnicmp(entry,"None",4)==0)
|
|
{
|
|
mipmapHint++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (mipmapHint)
|
|
{
|
|
if (mipmapHint>1)
|
|
{
|
|
*priority = Proxies::StateProxy::DetailPrority;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*priority = Proxies::StateProxy::AlphaPriority;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
if ((Cast_Pointer(StdMat*, sub)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
*priority = Proxies::StateProxy::AlphaPriority;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAlphaMode || materialState->SubTexmapOn(ID_OP))
|
|
{
|
|
*priority = Proxies::StateProxy::AlphaPriority;
|
|
}
|
|
else
|
|
{
|
|
*priority = Proxies::StateProxy::DefaultPriority;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetPriority(int priority)
|
|
{
|
|
//STOP(("Not Implemented"));
|
|
Check_Object(this);
|
|
switch (priority)
|
|
{
|
|
case Proxies::StateProxy::AlphaPriority:
|
|
{
|
|
bAlphaMode = true;
|
|
break;
|
|
}
|
|
}
|
|
/* if (Proxies::StateProxy::AlphaPriority == priority)
|
|
{
|
|
// Either set the alphasource to ALPHA_FILE or set the transparency to TRANSP_ADDITIVE
|
|
// Set the material to additive
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
int x=1;
|
|
}
|
|
Cast_Pointer(StdMat*, materialState)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
Cast_Pointer(StdMat*, sub)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetPriorityChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetPriorityChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetLighting(int *lighting_mode)
|
|
{
|
|
Check_Object(this);
|
|
if (NULL == materialState)
|
|
return false;
|
|
Check_Pointer(materialState);
|
|
|
|
// float fval = 0.0f;
|
|
// if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
// {
|
|
// fval = Cast_Pointer(StdMat*, materialState)->GetTexmapAmt(ID_SI,0);
|
|
// }
|
|
|
|
// if (materialState->SubTexmapOn(ID_SI) && (fval > 0.0f))
|
|
// {
|
|
// *lighting_mode = Proxies::StateProxy::LightingMode::LightingOffMode;
|
|
// return true;
|
|
// }
|
|
float fval = materialState->GetSelfIllum(0);
|
|
if (fval > 0.0f)
|
|
{
|
|
*lighting_mode = Proxies::StateProxy::LightingMode::LightingOffMode;
|
|
return true;
|
|
}
|
|
|
|
|
|
// *lighting_mode = (materialState->SubTexmapOn(ID_SI))?Proxies::StateProxy::LightingMode::LightingFaceMode
|
|
// :Proxies::StateProxy::LightingMode::LightingOffMode;
|
|
// return true;
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetLighting(int lighting_mode)
|
|
{
|
|
Check_Object(this);
|
|
/* if (Proxies::StateProxy::LightingMode::LightingOffMode == lighting_mode)
|
|
{
|
|
// Set the material to additive
|
|
if (materialState->ClassID() == Class_ID(DMTL_CLASS_ID,0))
|
|
{
|
|
if ((Cast_Pointer(StdMat*, materialState)->GetTransparencyType() == TRANSP_ADDITIVE))
|
|
{
|
|
int x=1;
|
|
}
|
|
Cast_Pointer(StdMat*, materialState)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
else if (materialState->ClassID() == Class_ID(MULTI_CLASS_ID,0))
|
|
{
|
|
int number_sub_materials = materialState->NumSubMtls();
|
|
for (int w=0;w<number_sub_materials;w++)
|
|
{
|
|
Mtl* sub = materialState->GetSubMtl(w);
|
|
Cast_Pointer(StdMat*, sub)->SetTransparencyType(TRANSP_ADDITIVE);
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetLightingChildPermission()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXState::SetLightingChildPermission(bool override)
|
|
{
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Proxies::TextureProxy*
|
|
MAXState::UseTextureProxy()
|
|
{
|
|
Check_Object(this);
|
|
|
|
//
|
|
//--------------------------
|
|
// Return the state proxy
|
|
//--------------------------
|
|
//
|
|
Proxies::StateLibrary *states = GetStateLibrary();
|
|
Check_Object(states);
|
|
|
|
MAXStateLibrary *max_states = GetStateLibrary();
|
|
Check_Object(max_states);
|
|
MAXScene *scene = max_states->GetSceneProxy();
|
|
|
|
MAXTextureLibrary *library =
|
|
Cast_Object(MAXTextureLibrary*, states->GetTextureLibrary());
|
|
|
|
int textureIndex = scene->bmpList.GetBitmapID(textureState);
|
|
if (textureIndex == -1)
|
|
return NULL;
|
|
|
|
MAXTexture *proxy = MAXTexture::MakeProxy(library, scene, textureIndex);
|
|
Register_Object(proxy);
|
|
//return library->UseTextureProxy(textureIndex);
|
|
//return library->UseTextureProxy(textureState);
|
|
Proxies::TextureProxy *proxyret = (NULL == materialState)?NULL:library->UseMatchingTextureProxy(proxy);
|
|
Unregister_Object(proxy);
|
|
proxy->Destroy();
|
|
return proxyret;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Proxies::TextureProxy*
|
|
MAXState::SetToMatchTextureProxy(Proxies::TextureProxy *texture)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(texture);
|
|
|
|
//
|
|
//----------------------------------------
|
|
// Have the texture library make our proxy
|
|
//----------------------------------------
|
|
//
|
|
Proxies::StateLibrary *state_library = GetStateLibrary();
|
|
Proxies::TextureLibrary *texture_library = state_library->GetTextureLibrary();
|
|
Proxies::TextureProxy *proxy = texture_library->UseMatchingTextureProxy(texture);
|
|
return proxy;
|
|
}
|
|
|
|
#if 0 // was input to fix a bug in the lower level proxies that has since been
|
|
// solved "we think"
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::IsEqualTo(Proxies::StateProxy *state)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(state);
|
|
if (StateProxy::IsEqualTo(state))
|
|
{
|
|
bool us = GetAlphaSetting();
|
|
MAXState *max_state = Cast_Object(MAXState *, state);
|
|
bool them = max_state->GetAlphaSetting();
|
|
if (them == us)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
MAXState::GetAlphaSetting()
|
|
{
|
|
if (textureState)
|
|
{
|
|
Check_Pointer(textureState);
|
|
int alpha_source = textureState->GetAlphaSource();
|
|
if (alpha_source == ALPHA_NONE)
|
|
return false;
|
|
else //if (alpha_source == ALPHA_FILE)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
//############################################################################
|
|
//############################ MAXStateLibrary #########################
|
|
//############################################################################
|
|
//
|
|
|
|
MAXStateLibrary::ClassData*
|
|
MAXStateLibrary::DefaultData = NULL;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXStateLibrary::InitializeClass()
|
|
{
|
|
Verify(!DefaultData);
|
|
DefaultData =
|
|
new ClassData(
|
|
MAXStateLibraryClassID,
|
|
"MAXStateLibrary",
|
|
StateLibrary::DefaultData
|
|
);
|
|
Register_Object(DefaultData);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXStateLibrary::TerminateClass()
|
|
{
|
|
Unregister_Object(DefaultData);
|
|
delete DefaultData;
|
|
DefaultData = NULL;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXStateLibrary::Destroy()
|
|
{
|
|
Check_Object(this);
|
|
Verify(referenceCount == 1);
|
|
Verify(activeStateProxies.IsEmpty());
|
|
STOP(("Not implemented"));
|
|
DetachReference();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MAXStateLibrary::MAXStateLibrary(MAXScene *scene):
|
|
StateLibrary(DefaultData, scene)
|
|
{
|
|
Check_Pointer(this);
|
|
multiMtl = NULL;
|
|
//
|
|
//---------------------------------------------------
|
|
// Get the number of textures present in the database
|
|
//---------------------------------------------------
|
|
//
|
|
textureLibrary = MAXTextureLibrary::MakeProxy(this);
|
|
Register_Object(textureLibrary);
|
|
Check_Object(this);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MAXStateLibrary::~MAXStateLibrary()
|
|
{
|
|
//TODO: clean up multiMtl
|
|
Check_Object(this);
|
|
Cast_Object(MAXTextureLibrary*, textureLibrary)->CloseLibrary();
|
|
textureLibrary->DetachReference();
|
|
Unregister_Object(textureLibrary);
|
|
textureLibrary = NULL;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXStateLibrary::TestInstance() const
|
|
{
|
|
Verify(IsDerivedFrom(DefaultData));
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Proxies::StateProxy*
|
|
MAXStateLibrary::UseMatchingStateProxy(Proxies::StateProxy *state,Proxies::TextureProxy *texture)
|
|
{
|
|
Check_Object(this);
|
|
Check_Object(state);
|
|
|
|
//
|
|
//------------------------------------
|
|
// See if this state needs to be added
|
|
//------------------------------------
|
|
//
|
|
if (!texture)
|
|
texture = state->UseTextureProxy();
|
|
else
|
|
{
|
|
texture->AttachReference();
|
|
Check_Object(texture);
|
|
}
|
|
|
|
if (!texture)
|
|
{
|
|
// Breakpoint here. Exporting didn't detect that there is no texture
|
|
int x=1;
|
|
}
|
|
MAXProxies::MAXState *our_state = NULL;
|
|
ChainIteratorOf< Proxies::StateProxy* > iterator(&activeStateProxies);
|
|
Proxies::StateProxy *iterator_state;
|
|
int index = 0;
|
|
while (iterator_state = iterator.ReadAndNext())
|
|
{
|
|
our_state = Cast_Object(MAXState *,iterator_state);
|
|
//iterator.Next();
|
|
if (state->IsEqualTo(our_state))
|
|
break;
|
|
our_state = NULL;
|
|
index++;
|
|
}
|
|
index = index >> 1;
|
|
//index++;
|
|
if (!our_state)
|
|
{
|
|
|
|
MAXProxies::MAXScene *scene = GetSceneProxy();
|
|
// Create the material and texture
|
|
StdMat *mat = NewDefaultStdMat();
|
|
scene->mtlList.AddMtl(mat);
|
|
// Add this material to the multimaterial object (connected to the node)
|
|
int numMat = multiMtl->NumSubMtls();
|
|
multiMtl->SetNumSubMtls(numMat+1);
|
|
multiMtl->SetSubMtl(numMat,mat);
|
|
scene->GetInterface()->GetMaterialLibrary().Add(mat);
|
|
|
|
static int addtex = 0;
|
|
BitmapTex *tex = NULL;
|
|
if (texture && addtex)
|
|
{
|
|
// Get Ready for FPU error here
|
|
|
|
tex = NewDefaultBitmapTex();
|
|
|
|
Stuff::MString name;
|
|
if (texture->GetName(&name))
|
|
{
|
|
tex->SetMapName(name+".tga");
|
|
}
|
|
else
|
|
STOP(("UseMatchingStateProxy - could not get texture name"));
|
|
if (tex->SupportTexDisplay() == TRUE)
|
|
{
|
|
tex->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);
|
|
tex->ActivateTexDisplay(TRUE);
|
|
}
|
|
scene->bmpList.AddBitmap(tex);
|
|
mat->SetSubTexmap(ID_DI,tex);
|
|
}
|
|
mat->EnableMap(ID_DI, TRUE);
|
|
mat->SetTexmapAmt(ID_DI, 1.f, 0);
|
|
if (tex && tex->SupportTexDisplay() == TRUE)
|
|
mat->SetMtlFlag(MTL_TEX_DISPLAY_ENABLED, TRUE);
|
|
|
|
our_state = MAXProxies::MAXState::MakeProxy(this, NULL,mat,tex,0);
|
|
|
|
// TODO: Use the matching texture proxy to add the texture to the bmp list
|
|
MAXCopyProcess process;
|
|
our_state->Copy(&process,state);
|
|
|
|
Register_Object(our_state);
|
|
AttachStateProxy(our_state);
|
|
}
|
|
else
|
|
our_state->matID = index;
|
|
our_state->AttachReference();
|
|
// Set the Material ID - only really used for import
|
|
/* if (texture)
|
|
texture->DetachReference();*/
|
|
|
|
return our_state;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
MAXStateLibrary::CloseLibrary()
|
|
{
|
|
Check_Object(this);
|
|
Verify(GetReferenceCount() == 1);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MAXState*
|
|
MAXStateLibrary::UseStateProxy(
|
|
Mtl *material,
|
|
BitmapTex *texture,
|
|
INode *mesh,
|
|
int indice
|
|
)
|
|
{
|
|
Check_Object(this);
|
|
//
|
|
//--------------------------------------------
|
|
// Look up the material and make a state proxy
|
|
//--------------------------------------------
|
|
//
|
|
MAXState *proxy =
|
|
MAXState::MakeProxy(this, mesh, material, texture, indice);
|
|
Register_Object(proxy);
|
|
return proxy;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MultiMtl *MAXStateLibrary::GetMultiMtl()
|
|
{
|
|
if (!multiMtl)
|
|
{
|
|
multiMtl = NewDefaultMultiMtl();
|
|
multiMtl->SetName("Mesh Materials");
|
|
multiMtl->SetNumSubMtls(0);
|
|
MAXProxies::MAXScene *scene = GetSceneProxy();
|
|
scene->GetInterface()->GetMaterialLibrary().Add(multiMtl);
|
|
}
|
|
return multiMtl;
|
|
}
|
|
|
|
void
|
|
MAXStateLibrary::CalculateMaxState(
|
|
MAXState *state,
|
|
Proxies::StateProxy *proxy,
|
|
Proxies::TextureProxy *texture
|
|
)
|
|
{
|
|
/* Check_Object(this);
|
|
Check_Pointer(state);
|
|
Check_Object(proxy);
|
|
|
|
//
|
|
//-----------------------------------------------------------------------
|
|
// Find the texture proxy from the state proxy unless there is a specific
|
|
// texture override
|
|
//-----------------------------------------------------------------------
|
|
//
|
|
if (!texture)
|
|
texture = proxy->UseTextureProxy();
|
|
else
|
|
{
|
|
Check_Object(texture);
|
|
texture->AttachReference();
|
|
}
|
|
|
|
//
|
|
//---------------------
|
|
// Deal with the states
|
|
//---------------------
|
|
//
|
|
|
|
bool permission, onOff;
|
|
Proxies::StateProxy::AlphaMode alphaMode;
|
|
|
|
if(proxy->GetAlpha(&alphaMode))
|
|
{
|
|
state->SetAlpha(alphaMode);
|
|
}
|
|
|
|
permission = proxy->GetAlphaChildPermission();
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::AlphaMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::AlphaMask
|
|
);
|
|
}
|
|
|
|
StateProxy::FilterMode filterMode;
|
|
|
|
if(proxy->GetFilter(&filterMode))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::FilterMask
|
|
);
|
|
|
|
switch(filterMode)
|
|
{
|
|
case StateProxy::NoFilterMode:
|
|
state->SetFilterMode(MLRState::NoFilterMode);
|
|
break;
|
|
case StateProxy::BiLinearFilterMode:
|
|
state->SetFilterMode(MLRState::BiLinearFilterMode);
|
|
break;
|
|
case StateProxy::TriLinearFilterMode:
|
|
state->SetFilterMode(MLRState::TriLinearFilterMode);
|
|
break;
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetFilterChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::FilterMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::FilterMask
|
|
);
|
|
}
|
|
|
|
StateProxy::FogMode fogMode;
|
|
if(proxy->GetFog(&fogMode))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::FogMask
|
|
);
|
|
state->SetFogMode(fogMode);
|
|
}
|
|
|
|
permission = proxy->GetFogChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::FogMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::FogMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetDither(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::DitherMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetDitherOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetDitherOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetDitherChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::DitherMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::DitherMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetSpecular(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::SpecularMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetSpecularOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetSpecularOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetSpecularChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::SpecularMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::SpecularMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetTextureCorrection(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::TextureCorrectionMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetTextureCorrectionOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetTextureCorrectionOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetTextureCorrectionChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::TextureCorrectionMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::TextureCorrectionMask
|
|
);
|
|
}
|
|
|
|
StateProxy::TextureWrapMode textureWrapMode;
|
|
|
|
if(proxy->GetTextureWrap(&textureWrapMode))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::TextureWrapMask
|
|
);
|
|
|
|
if(textureWrapMode==StateProxy::TextureWrap)
|
|
{
|
|
state->SetTextureWrapMode(MLRState::TextureWrap);
|
|
}
|
|
else
|
|
{
|
|
state->SetTextureWrapMode(MLRState::TextureClamp);
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetTextureWrapChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::TextureWrapMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::TextureWrapMask
|
|
);
|
|
}
|
|
|
|
StateProxy::WireFrameMode wireFrameMode;
|
|
|
|
if(proxy->GetWireFrame(&wireFrameMode))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::WireFrameMask
|
|
);
|
|
|
|
switch(wireFrameMode)
|
|
{
|
|
case StateProxy::WireFrameOffMode:
|
|
state->SetWireFrameMode(MLRState::WireFrameOffMode);
|
|
break;
|
|
case StateProxy::WireFrameOnlyMode:
|
|
state->SetWireFrameMode(MLRState::WireFrameOnlyMode);
|
|
break;
|
|
case StateProxy::WireFrameAddMode:
|
|
state->SetWireFrameMode(MLRState::WireFrameAddMode);
|
|
break;
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetWireFrameChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::WireFrameMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::WireFrameMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetZBufferCompare(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::ZBufferCompareMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetZBufferCompareOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetZBufferCompareOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetZBufferCompareChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::ZBufferCompareMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::ZBufferCompareMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetZBufferWrite(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::ZBufferWriteMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetZBufferWriteOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetZBufferWriteOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetZBufferWriteChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::ZBufferWriteMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::ZBufferWriteMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetFlatColoring(&onOff))
|
|
{
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::FlatColoringMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetFlatColoringOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetFlatColoringOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetFlatColoringChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetRenderPermissionMask(
|
|
state->GetRenderPermissionMask() | MLRState::FlatColoringMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetRenderPermissionMask() & ~MLRState::FlatColoringMask
|
|
);
|
|
}
|
|
|
|
if(proxy->GetBackface(&onOff))
|
|
{
|
|
state->SetProcessDeltaMask(
|
|
state->GetProcessDeltaMask() | MLRState::BackFaceMask
|
|
);
|
|
|
|
if(onOff)
|
|
{
|
|
state->SetBackFaceOn();
|
|
}
|
|
else
|
|
{
|
|
state->SetBackFaceOff();
|
|
}
|
|
}
|
|
|
|
permission = proxy->GetBackfaceChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() | MLRState::BackFaceMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() & ~MLRState::BackFaceMask
|
|
);
|
|
}
|
|
|
|
int priority;
|
|
if(proxy->GetPriority(&priority))
|
|
{
|
|
state->SetProcessDeltaMask(
|
|
state->GetProcessDeltaMask() | MLRState::PriorityMask
|
|
);
|
|
|
|
state->SetPriority(priority);
|
|
}
|
|
|
|
permission = proxy->GetPriorityChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() | MLRState::PriorityMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() & ~MLRState::PriorityMask
|
|
);
|
|
}
|
|
|
|
int lightingMode;
|
|
|
|
if(proxy->GetLighting(&lightingMode))
|
|
{
|
|
state->SetProcessDeltaMask(
|
|
state->GetProcessDeltaMask() | MLRState::LightingMask
|
|
);
|
|
|
|
int mlr_mode = 0;
|
|
if (lightingMode&StateProxy::LightingLightMapMode)
|
|
mlr_mode |= MLRState::LightMapLightingMode;
|
|
if (lightingMode&StateProxy::LightingVertexMode)
|
|
mlr_mode |= MLRState::VertexLightingMode;
|
|
if (lightingMode&StateProxy::LightingLookupMode)
|
|
mlr_mode |= MLRState::LookupLightingMode;
|
|
if (lightingMode&StateProxy::LightingFaceMode)
|
|
mlr_mode |= MLRState::FaceLightingMode;
|
|
state->SetLightingMode(mlr_mode);
|
|
}
|
|
|
|
permission = proxy->GetLightingChildPermission();
|
|
|
|
if(permission==true)
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() | MLRState::LightingMask
|
|
);
|
|
}
|
|
else
|
|
{
|
|
state->SetProcessPermissionMask(
|
|
state->GetProcessPermissionMask() & ~MLRState::LightingMask
|
|
);
|
|
}
|
|
|
|
//
|
|
//----------------------
|
|
// Deal with the texture
|
|
//----------------------
|
|
//
|
|
/* if (texture)
|
|
{
|
|
Check_Object(texture);
|
|
MLRTexturePoolProxy *textures =
|
|
Cast_Object(MLRTexturePoolProxy*, GetTextureLibrary());
|
|
Check_Object(textures);
|
|
MLRTextureProxy *our_texture =
|
|
Cast_Object(
|
|
MLRTextureProxy*,
|
|
textures->UseMatchingTextureProxy(texture)
|
|
);
|
|
MLRTexture *mlr_texture = our_texture->GetMLRTexture();
|
|
Check_Object(mlr_texture);
|
|
|
|
state->SetTextureHandle(mlr_texture->GetTextureHandle());
|
|
state->SetRenderDeltaMask(
|
|
state->GetRenderDeltaMask() | MLRState::TextureMask
|
|
);
|
|
|
|
our_texture->DetachReference();
|
|
texture->DetachReference();
|
|
}*/
|
|
}
|