You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

846 lines
27 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, 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/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "hsTypes.h"
#include "plPassMtl.h"
#include "resource.h"
//extern ClassDesc2* GetMaxLayerDesc();
#include "Shaders.h"
#include "../MaxComponent/plMaxAnimUtils.h"
#include "plPassBaseParamIDs.h"
#include "plPassMtlBasicPB.h"
#include "plPassMtlLayersPB.h"
#include "iparamm2.h"
#include "Layers/plLayerTex.h"
#include "Layers/plStaticEnvLayer.h"
#include "hsBitVector.h"
extern HINSTANCE hInstance;
class plPassMtlClassDesc : public ClassDesc2
{
public:
int IsPublic() { return TRUE; }
void* Create(BOOL loading) { return TRACKED_NEW plPassMtl(loading); }
const TCHAR* ClassName() { return GetString(IDS_PASS_MTL); }
SClass_ID SuperClassID() { return MATERIAL_CLASS_ID; }
Class_ID ClassID() { return PASS_MTL_CLASS_ID; }
const TCHAR* Category() { return NULL; }
const TCHAR* InternalName() { return _T("PlasmaMaterial"); }
HINSTANCE HInstance() { return hInstance; }
};
static plPassMtlClassDesc plPassMtlDesc;
ClassDesc2* GetPassMtlDesc() { return &plPassMtlDesc; }
// For initializing paramblock descriptor
ParamBlockDesc2 *GetPassBasicPB();
ParamBlockDesc2 *GetPassAdvPB();
ParamBlockDesc2 *GetPassLayersPB();
#include "plPassMtlAdvPBDec.h"
#include "plPassMtlBasicPBDec.h"
#include "plPassMtlLayersPBDec.h"
#include "plPassMtlAnimPBDec.h"
#include "plAnimStealthNode.h"
plPassMtl::plPassMtl(BOOL loading) : plPassMtlBase( loading )
{
plPassMtlDesc.MakeAutoParamBlocks( this );
fLayersPB->SetValue( kPassLayBase, 0, TRACKED_NEW plLayerTex );
fLayersPB->SetValue( kPassLayTop, 0, TRACKED_NEW plLayerTex );
// If we do this later (like, when the dialog loads) something blows up,
// somewhere in Max. It didn't in 4, it does in 7. This seems to fix it.
if (!loading)
IVerifyStealthPresent(ENTIRE_ANIMATION_NAME);
}
plPassMtl::~plPassMtl()
{
}
ParamDlg* plPassMtl::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp)
{
fIMtlParams = imp;
IAutoMParamDlg* masterDlg = plPassMtlDesc.CreateParamDlgs(hwMtlEdit, imp, this);
return (ParamDlg*)masterDlg;
}
BOOL plPassMtl::SetDlgThing(ParamDlg* dlg)
{
return FALSE;
}
Interval plPassMtl::Validity(TimeValue t)
{
#if 0 // mf horse
Interval valid = FOREVER;
/* for (int i = 0; i < fSubTexmap.Count(); i++)
{
if (fSubTexmap[i])
valid &= fSubTexmap[i]->Validity(t);
}
*/
// float u;
// fPBlock->GetValue(pb_spin,t,u,valid);
return valid;
#else // mf horse
const char* name = GetName();
// mf horse - Hacking in something like real validity checking
// to get material animations working. No warranty, this is just
// better than nothing.
Interval v = FOREVER;
fBasicPB->GetValidity(t, v);
fAdvPB->GetValidity(t, v);
if( fLayersPB->GetTexmap(kPassLayBase) )
v &= fLayersPB->GetTexmap(kPassLayBase)->Validity(t);
if( fLayersPB->GetTexmap(kPassLayTop) )
v &= fLayersPB->GetTexmap(kPassLayTop)->Validity(t);
return v;
#endif // mf horse
}
//// GetReference ////////////////////////////////////////////////////////////
// Note: need to overload because MAX for some reason writes out the
// references by their INDEX. ARRRRGH!
RefTargetHandle plPassMtl::GetReference( int i )
{
switch( i )
{
case kRefBasic: return fBasicPB;
case kRefAdv: return fAdvPB;
case kRefLayers: return fLayersPB;
case kRefAnim: return fAnimPB;
}
return plPassMtlBase::GetReference( i );
}
//// SetReference ////////////////////////////////////////////////////////////
// Note: need to overload because MAX for some reason writes out the
// references by their INDEX. ARRRRGH!
void plPassMtl::SetReference(int i, RefTargetHandle rtarg)
{
if (i == kRefBasic)
fBasicPB = (IParamBlock2 *)rtarg;
else if (i == kRefAdv)
fAdvPB = (IParamBlock2 *)rtarg;
else if (i == kRefLayers)
fLayersPB = (IParamBlock2 *)rtarg;
else if (i == kRefAnim)
fAnimPB = (IParamBlock2 *)rtarg;
else
plPassMtlBase::SetReference( i, rtarg );
}
/*===========================================================================*\
| Subanim & References support
\*===========================================================================*/
int plPassMtl::NumSubs()
{
return 6;
}
TSTR plPassMtl::SubAnimName(int i)
{
switch (i)
{
case 0: return fBasicPB->GetLocalName();
case 1: return fAdvPB->GetLocalName();
case 2: return fLayersPB->GetLocalName();
case 3: return fAnimPB->GetLocalName();
case 4: return "Base Layer";
case 5: return "Top Layer";
}
return "";
}
Animatable* plPassMtl::SubAnim(int i)
{
switch (i)
{
case 0: return fBasicPB;
case 1: return fAdvPB;
case 2: return fLayersPB;
case 3: return fAnimPB;
case 4: return fLayersPB->GetTexmap(kPassLayBase);
case 5:
if (fLayersPB->GetInt(kPassLayTopOn))
return fLayersPB->GetTexmap(kPassLayTop);
break;
}
return NULL;
}
int plPassMtl::NumParamBlocks()
{
return 4;
}
IParamBlock2* plPassMtl::GetParamBlock(int i)
{
return (IParamBlock2*)GetReference(i);
}
IParamBlock2* plPassMtl::GetParamBlockByID(BlockID id)
{
if (fBasicPB->ID() == id)
return fBasicPB;
else if (fAdvPB->ID() == id)
return fAdvPB;
else if (fLayersPB->ID() == id)
return fLayersPB;
else if (fAnimPB->ID() == id)
return fAnimPB;
return NULL;
}
RefResult plPassMtl::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message)
{
return plPassMtlBase::NotifyRefChanged( changeInt, hTarget, partID, message );
}
////////////////////////////////////////////////////////////////////////////////
// Subtexmap access
int plPassMtl::NumSubTexmaps()
{
return 2;
}
Texmap* plPassMtl::GetSubTexmap(int i)
{
if (i == 0)
return fLayersPB->GetTexmap(kPassLayBase);
else if (i == 1)
return fLayersPB->GetTexmap(kPassLayTop);
return NULL;
}
void plPassMtl::SetSubTexmap(int i, Texmap *m)
{
if (i == 0)
fLayersPB->SetValue(kPassLayBase, 0, m);
else if (i == 1)
fLayersPB->SetValue(kPassLayTop, 0, m);
}
TSTR plPassMtl::GetSubTexmapSlotName(int i)
{
if (i == 0)
return "Base";
else if (i == 1)
return "Top";
return "";
}
TSTR plPassMtl::GetSubTexmapTVName(int i)
{
return GetSubTexmapSlotName(i);
}
int plPassMtl::SubTexmapOn(int i)
{
if (i == 0)
return 1;
else if (i == 1 && fLayersPB->GetInt(kPassLayTopOn))
return 1;
return 0;
}
/*===========================================================================*\
| Updating and cloning
\*===========================================================================*/
RefTargetHandle plPassMtl::Clone(RemapDir &remap)
{
plPassMtl *mnew = TRACKED_NEW plPassMtl(FALSE);
plPassMtlBase::ICloneBase( mnew, remap );
return (RefTargetHandle)mnew;
}
void plPassMtl::ICloneRefs( plPassMtlBase *target, RemapDir &remap )
{
target->ReplaceReference(kRefBasic, remap.CloneRef(fBasicPB));
target->ReplaceReference(kRefAdv, remap.CloneRef(fAdvPB));
target->ReplaceReference(kRefLayers, remap.CloneRef(fLayersPB));
target->ReplaceReference(kRefAnim, remap.CloneRef(fAnimPB));
}
void plPassMtl::NotifyChanged()
{
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
void plPassMtl::Update(TimeValue t, Interval& valid)
{
// mf horse - Hacking in something like real validity checking
// to get material animations working. No warranty, this is just
// better than nothing.
if (!fIValid.InInterval(t))
{
fIValid.SetInfinite();
if( fLayersPB->GetTexmap(kPassLayBase) )
fLayersPB->GetTexmap(kPassLayBase)->Update(t, fIValid);
if( fLayersPB->GetTexmap(kPassLayTop) )
fLayersPB->GetTexmap(kPassLayTop)->Update(t, fIValid);
// fLayersPB->GetValue(kMtlLayLayer1On, t, fMapOn[0], fIValid);
/*
for (int i = 0; i < fSubTexmap.Count(); i++)
{
if (fSubTexmap[i])
fSubTexmap[i]->Update(t,fIValid);
}
*/
}
// Our wonderful way of version handling--if the runtimeColor is (-1,-1,-1), we know it's
// just been initialized, so set it to the static color (this lets us do the right thing for
// loading old paramBlocks)
if( fBasicPB )
{
Color run = fBasicPB->GetColor( kPassBasRunColor, 0 );
if( run == Color(-1,-1,-1) )
{
fBasicPB->SetValue( kPassBasRunColor, 0, fBasicPB->GetColor( kPassBasColor, 0 ) );
}
// Also, if shineStr is anything other than -1, then it must be an old paramblock and we need
// to convert to our new specColor (we know this because the original valid range was 0-100)
int shine = fBasicPB->GetInt( kPassBasShineStr, 0 );
if( shine != -1 )
{
fBasicPB->SetValue( kPassBasSpecColor, 0, Color( (float)shine / 100.f, (float)shine / 100.f, (float)shine / 100.f ) );
fBasicPB->SetValue( kPassBasShineStr, 0, (int)-1 );
}
}
valid &= fIValid;
}
/*===========================================================================*\
| Determine the characteristics of the material
\*===========================================================================*/
void plPassMtl::SetAmbient(Color c, TimeValue t) {}
void plPassMtl::SetDiffuse(Color c, TimeValue t) {}
void plPassMtl::SetSpecular(Color c, TimeValue t) {}
void plPassMtl::SetShininess(float v, TimeValue t) {}
Color plPassMtl::GetAmbient(int mtlNum, BOOL backFace) { return Color(0,0,0); }
Color plPassMtl::GetDiffuse(int mtlNum, BOOL backFace) { return Color(0,0,0); }
Color plPassMtl::GetSpecular(int mtlNum, BOOL backFace) { return Color(0,0,0); }
float plPassMtl::GetXParency(int mtlNum, BOOL backFace)
{
int opacity = fBasicPB->GetInt( kPassBasOpacity, 0 );
float alpha = 1.0f - ( (float)opacity / 100.0f );
return alpha;
}
float plPassMtl::GetShininess(int mtlNum, BOOL backFace) { return 0.0f; }
float plPassMtl::GetShinStr(int mtlNum, BOOL backFace) { return 0.0f; }
float plPassMtl::WireSize(int mtlNum, BOOL backFace) { return 0.0f; }
/////////////////////////////////////////////////////////////////
void plPassMtl::SetupGfxMultiMaps(TimeValue t, Material *mtl, MtlMakerCallback &cb)
{
#if 0
if (texHandleValid.InInterval(t)) {
mtl->texture.SetCount(numTexHandlesUsed);
for (int i=0; i<numTexHandlesUsed; i++) {
if (texHandle[i]) {
mtl->texture[i].textHandle = texHandle[i]->GetHandle();
Texmap *tx = (*maps)[useSubForTex[i]].map;
cb.GetGfxTexInfoFromTexmap(t, mtl->texture[i], tx );
SetTexOps(mtl,i,texOpsType[i]);
}
}
return;
}
#endif
#if 0 // WTF?!?!?!?
Texmap *tx[2];
int diffChan = stdIDToChannel[ ID_DI ];
int opacChan = stdIDToChannel[ ID_OP ];
tx[0] = (*maps)[diffChan].IsActive()?(*maps)[diffChan].map:NULL;
tx[1] = (*maps)[opacChan].IsActive()?(*maps)[opacChan].map:NULL;
#endif
int nsupport = cb.NumberTexturesSupported();
#if 0
BITMAPINFO *bmi[NTEXHANDLES];
int nmaps=0;
for (int i=0; i<NTEXHANDLES; i++) {
if (tx[i]) nmaps ++;
bmi[i] = NULL;
}
mtl->texture.SetCount(nmaps);
if (nmaps==0)
return;
for (i=0; i<nmaps; i++)
mtl->texture[i].textHandle = NULL;
texHandleValid.SetInfinite();
Interval valid;
BOOL needDecal = FALSE;
int ntx = 0;
int op;
int forceW = 0;
int forceH = 0;
if (tx[0]) {
cb.GetGfxTexInfoFromTexmap(t, mtl->texture[0], tx[0]);
TextureInfo &ti = mtl->texture[0];
if (ti.tiling[0]==GW_TEX_NO_TILING||ti.tiling[1]==GW_TEX_NO_TILING)
needDecal = TRUE;
op = needDecal?TXOP_ALPHABLEND:TXOP_MODULATE;
bmi[0] = tx[0]->GetVPDisplayDIB(t,cb,valid,FALSE);
if (bmi[0]) {
texHandleValid &= valid;
useSubForTex[0] = diffChan;
ntx = 1;
forceW = bmi[0]->bmiHeader.biWidth;
forceH = bmi[0]->bmiHeader.biHeight;
}
}
if (tx[1]) {
cb.GetGfxTexInfoFromTexmap(t, mtl->texture[ntx], tx[1]);
if (nsupport>ntx) {
bmi[1] = tx[1]->GetVPDisplayDIB(t,cb,valid,TRUE);
if (bmi[1]) {
texHandleValid &= valid;
StuffAlpha(bmi[1], (*maps)[opacChan].amount, GetOpacity(t),ntx?whiteCol:pShader->GetDiffuseClr(t));
texHandle[ntx] = cb.MakeHandle(bmi[1]);
bmi[1] = NULL;
mtl->texture[ntx].textHandle = texHandle[ntx]->GetHandle();
SetTexOps(mtl,ntx,TXOP_OPACITY);
useSubForTex[ntx] = opacChan;
ntx++;
}
}
else {
if (!needDecal) {
TextureInfo ti;
// if (SameUV(mtl->texture[0],mtl->texture[1])) {
// Not really correct to combine channels for different UV's but what the heck.
bmi[1] = tx[1]->GetVPDisplayDIB(t,cb,valid,TRUE, forceW, forceH);
if (bmi[1]) {
texHandleValid &= valid;
StuffAlphaInto(bmi[1], bmi[0], (*maps)[opacChan].amount, GetOpacity(t));
op = TXOP_OPACITY;
free(bmi[1]);
bmi[1] = NULL;
}
// }
}
}
}
if (bmi[0]) {
texHandle[0] = cb.MakeHandle(bmi[0]);
bmi[0] = NULL;
mtl->texture[0].textHandle = texHandle[0]->GetHandle();
SetTexOps(mtl,0,op);
}
mtl->texture.SetCount(ntx);
numTexHandlesUsed = ntx;
#endif
}
/*===========================================================================*\
| Actual shading takes place
\*===========================================================================*/
void plPassMtl::GetInterpVtxValue(int channel, ShadeContext &sc, Point3 &val)
{
Mesh *mesh = sc.globContext->GetRenderInstance(sc.NodeID())->mesh;
if (mesh != nil)
{
Face *maxFace = &mesh->faces[ sc.FaceNumber() ];
UVVert *map = mesh->mapVerts(channel);
if (map != nil)
{
Point3 p0 = map[maxFace->getVert( 0 )];
Point3 p1 = map[maxFace->getVert( 1 )];
Point3 p2 = map[maxFace->getVert( 2 )];
Point3 interp = sc.BarycentricCoords();
val.x = interp.x * p0.x + interp.y * p1.x + interp.z * p2.x;
val.y = interp.x * p0.y + interp.y * p1.y + interp.z * p2.y;
val.z = interp.x * p0.z + interp.y * p1.z + interp.z * p2.z;
return;
}
}
// No value defined... set default.
if (channel == MAP_SHADING)
val.x = val.y = val.z = 0.0f;
else
val.x = val.y = val.z = 1.0f;
}
void plPassMtl::Shade(ShadeContext& sc)
{
// Get the background color
Color backColor, backTrans;
sc.GetBGColor(backColor, backTrans);
ShadeWithBackground(sc, backColor);
}
//// Requirements ////////////////////////////////////////////////////////////
// Tells MAX what we need to render ourselves properly, such as translucency,
// two-sidedness, etc. Flags are in imtl.h in the MAX SDK.
ULONG plPassMtl::Requirements( int subMtlNum )
{
ULONG req = 0;
req = Mtl::Requirements( subMtlNum );
// Uncomment this to get the background color fed to our ShadeWithBackground()
// (slower processing tho)
//req |= MTLREQ_BGCOL;
req |= MTLREQ_UV;
int blendType = fLayersPB->GetInt( kPassLayOutputBlend );
if( blendType == kBlendAdd )
req |= MTLREQ_ADDITIVE_TRANSP | MTLREQ_TRANSP;
else if( blendType == kBlendAlpha )
req |= MTLREQ_TRANSP;
else if( fBasicPB->GetInt( kPassBasOpacity, 0 ) != 100 )
req |= MTLREQ_TRANSP;
if( fAdvPB->GetInt( kPBAdvTwoSided ) )
req |= MTLREQ_2SIDE;
if (req & MTLREQ_FACEMAP)
{
int i = 0;
}
return req;
}
void plPassMtl::ShadeWithBackground(ShadeContext &sc, Color background, bool useVtxAlpha /* = true */)
{
#if 1
// old
#if 0
Color lightCol,rescol, diffIllum0;
RGBA mval;
Point3 N0,P;
BOOL bumped = FALSE;
int i;
if (gbufID)
sc.SetGBufferID(gbufID);
if (sc.mode == SCMODE_SHADOW) {
float opac = 0.0;
for (i=0; i < NumSubTexmaps(); i++) {
if (SubTexmapOn(i)) {
hsMaxLayerBase *hsmLay = (hsMaxLayerBase *)GetSubTexmap(i);
opac += hsmLay->GetOpacity(t);
}
}
float f = 1.0f - opac;
sc.out.t = Color(f,f,f);
return;
}
N0 = sc.Normal();
P = sc.P();
#endif
TimeValue t = sc.CurTime();
Color color(0, 0, 0);
float alpha = 0.0;
// Evaluate Base layer
Texmap *map = fLayersPB->GetTexmap(kPassLayBase);
if (map && ( map->ClassID() == LAYER_TEX_CLASS_ID
|| map->ClassID() == STATIC_ENV_LAYER_CLASS_ID ) )
{
plLayerTex *layer = (plLayerTex*)map;
AColor evalColor = layer->EvalColor(sc);
color = evalColor;
alpha = evalColor.a;
}
// Evaluate Top layer, if it's on
if (fLayersPB->GetInt(kPassLayTopOn))
{
Texmap *map = fLayersPB->GetTexmap(kPassLayTop);
if (map && ( map->ClassID() == LAYER_TEX_CLASS_ID
|| map->ClassID() == STATIC_ENV_LAYER_CLASS_ID
|| map->ClassID() == ANGLE_ATTEN_LAYER_CLASS_ID) )
{
plPlasmaMAXLayer *layer = (plPlasmaMAXLayer*)map;
AColor evalColor = layer->EvalColor(sc);
// Blend layers
if( !layer->DiscardColor() )
{
int blendType = fLayersPB->GetInt(kPassLayBlend);
switch (blendType)
{
case kBlendAdd:
color += evalColor * evalColor.a;
break;
case kBlendAlpha:
color = (1.0f - evalColor.a) * color + evalColor.a * evalColor;
break;
case kBlendMult:
color *= evalColor;
break;
default: // No blend...
color = evalColor;
break;
}
}
if( !layer->DiscardAlpha() )
{
int alphaType = fLayersPB->GetInt(kPassLayOutputBlend);
switch( alphaType )
{
case kAlphaMultiply:
alpha *= evalColor.a;
break;
case kAlphaAdd:
alpha += evalColor.a;
break;
case kAlphaDiscard:
default:
break;
}
}
}
}
#if 1
AColor black;
black.Black();
AColor white;
white.White();
SIllumParams ip;
if (fBasicPB->GetInt(kPassBasEmissive))
{
// Emissive objects don't get shaded
ip.diffIllum = fBasicPB->GetColor(kPassBasColorAmb, t) * color;
ip.diffIllum.ClampMinMax();
ip.specIllum = black;
}
else
{
//
// Shading setup
//
// Setup the parameters for the shader
ip.amb = fBasicPB->GetColor(kPassBasColorAmb, t);
ip.diff = fBasicPB->GetColor(kPassBasColor, t) * color;
ip.diffIllum = black;
ip.specIllum = black;
ip.N = sc.Normal();
ip.V = sc.V();
//
// Specularity
//
if (fBasicPB->GetInt(kPassBasUseSpec, t))
{
ip.sh_str = 1.f;
ip.spec = fBasicPB->GetColor( kPassBasSpecColor, t );
ip.ph_exp = (float)pow(2.0f,float(fBasicPB->GetInt(kPassBasShine, t)) / 10.0f);
ip.shine = float(fBasicPB->GetInt(kPassBasShine, t)) / 100.0f;
}
else
{
ip.spec = black;
ip.sh_str = 0;
ip.ph_exp = 0;
ip.shine = 0;
}
ip.softThresh = 0;
//
// Do the shading
Shader *myShader = GetShader(SHADER_BLINN);
myShader->Illum(sc, ip);
// Override shader parameters
if (fAdvPB->GetInt(kPBAdvNoShade))
{
ip.diffIllum = black;
ip.specIllum = black;
}
if (fAdvPB->GetInt(kPBAdvWhite))
{
ip.diffIllum = white;
ip.specIllum = black;
}
ip.specIllum.ClampMinMax();
ip.diffIllum = ip.amb * sc.ambientLight + ip.diff * ip.diffIllum;
ip.diffIllum.ClampMinMax();
}
// AColor returnColor = AColor(opac * ip.diffIllum + ip.specIllum, opac)
#endif
// Get opacity and combine with alpha
float opac = float(fBasicPB->GetInt(kPassBasOpacity, t)) / 100.0f;
alpha *= opac;
float vtxAlpha = 1.0f;
if (useVtxAlpha && GetOutputBlend() == plPassMtlBase::kBlendAlpha)
{
Point3 p;
GetInterpVtxValue(MAP_ALPHA, sc, p);
vtxAlpha = p.x;
}
alpha *= vtxAlpha;
// MAX will do the additive/alpha/no blending for us based on what Requirements()
// we tell it. However, since MAX's formula is bgnd*sc.out.t + sc.out.c,
// we have to multiply our output color by the alpha.
// If we ever need a more complicated blending function, you can request the
// background color via Requirements() (otherwise it's just black) and then do
// the blending yourself; however, if the transparency isn't set, the shadows
// will be opaque, so be careful.
Color outC = ip.diffIllum + ip.specIllum;
sc.out.c = ( outC * alpha );
sc.out.t = Color( 1.f - alpha, 1.f - alpha, 1.f - alpha );
#endif
}
float plPassMtl::EvalDisplacement(ShadeContext& sc)
{
return 0.0f;
}
Interval plPassMtl::DisplacementValidity(TimeValue t)
{
Interval iv;
iv.SetInfinite();
return iv;
}
bool plPassMtl::HasAlpha()
{
return ((plLayerTex *)fLayersPB->GetTexmap(kPassLayBase))->HasAlpha();
}
// Massive list of inherited accessor functions for ParamBlock data
// Advanced Block
int plPassMtl::GetBasicWire() { return fAdvPB->GetInt(kPBAdvWire); }
int plPassMtl::GetMeshOutlines() { return fAdvPB->GetInt(kPBAdvMeshOutlines); }
int plPassMtl::GetTwoSided() { return fAdvPB->GetInt(kPBAdvTwoSided); }
int plPassMtl::GetSoftShadow() { return fAdvPB->GetInt(kPBAdvSoftShadow); }
int plPassMtl::GetNoProj() { return fAdvPB->GetInt(kPBAdvNoProj); }
int plPassMtl::GetVertexShade() { return fAdvPB->GetInt(kPBAdvVertexShade); }
int plPassMtl::GetNoShade() { return fAdvPB->GetInt(kPBAdvNoShade); }
int plPassMtl::GetNoFog() { return fAdvPB->GetInt(kPBAdvNoFog); }
int plPassMtl::GetWhite() { return fAdvPB->GetInt(kPBAdvWhite); }
int plPassMtl::GetZOnly() { return fAdvPB->GetInt(kPBAdvZOnly); }
int plPassMtl::GetZClear() { return fAdvPB->GetInt(kPBAdvZClear); }
int plPassMtl::GetZNoRead() { return fAdvPB->GetInt(kPBAdvZNoRead); }
int plPassMtl::GetZNoWrite() { return fAdvPB->GetInt(kPBAdvZNoWrite); }
int plPassMtl::GetZInc() { return fAdvPB->GetInt(kPBAdvZInc); }
int plPassMtl::GetAlphaTestHigh() { return fAdvPB->GetInt(kPBAdvAlphaTestHigh); }
// Animation block
char * plPassMtl::GetAnimName() { return fAnimPB->GetStr(kPBAnimName); }
int plPassMtl::GetAutoStart() { return fAnimPB->GetInt(kPBAnimAutoStart); }
int plPassMtl::GetLoop() { return fAnimPB->GetInt(kPBAnimLoop); }
char * plPassMtl::GetAnimLoopName() { return fAnimPB->GetStr(kPBAnimLoopName); }
int plPassMtl::GetEaseInType() { return fAnimPB->GetInt(kPBAnimEaseInType); }
float plPassMtl::GetEaseInNormLength() { return fAnimPB->GetFloat(kPBAnimEaseInLength); }
float plPassMtl::GetEaseInMinLength() { return fAnimPB->GetFloat(kPBAnimEaseInMin); }
float plPassMtl::GetEaseInMaxLength() { return fAnimPB->GetFloat(kPBAnimEaseInMax); }
int plPassMtl::GetEaseOutType() { return fAnimPB->GetInt(kPBAnimEaseOutType); }
float plPassMtl::GetEaseOutNormLength() { return fAnimPB->GetFloat(kPBAnimEaseOutLength); }
float plPassMtl::GetEaseOutMinLength() { return fAnimPB->GetFloat(kPBAnimEaseOutMin); }
float plPassMtl::GetEaseOutMaxLength() { return fAnimPB->GetFloat(kPBAnimEaseOutMax); }
int plPassMtl::GetUseGlobal() { return fAnimPB->GetInt(ParamID(kPBAnimUseGlobal)); }
char * plPassMtl::GetGlobalVarName() { return fAnimPB->GetStr(ParamID(kPBAnimGlobalName)); }
// Basic block
int plPassMtl::GetColorLock() { return fBasicPB->GetInt(kPassBasColorLock); }
Color plPassMtl::GetAmbColor() { return fBasicPB->GetColor(kPassBasColorAmb); }
Color plPassMtl::GetColor() { return fBasicPB->GetColor(kPassBasColor); }
int plPassMtl::GetOpacity() { return fBasicPB->GetInt(kPassBasOpacity); }
int plPassMtl::GetEmissive() { return fBasicPB->GetInt(kPassBasEmissive); }
int plPassMtl::GetUseSpec() { return fBasicPB->GetInt(kPassBasUseSpec); }
int plPassMtl::GetShine() { return fBasicPB->GetInt(kPassBasShine); }
Color plPassMtl::GetSpecularColor() { return fBasicPB->GetColor(kPassBasSpecColor); }
int plPassMtl::GetDiffuseColorLock() { return fBasicPB->GetInt(kPassBasDiffuseLock); }
Color plPassMtl::GetRuntimeColor() { return fBasicPB->GetColor(kPassBasRunColor); }
Control *plPassMtl::GetPreshadeColorController() { return fBasicPB->GetController(ParamID(kPassBasColor)); }
Control *plPassMtl::GetAmbColorController() { return fBasicPB->GetController(ParamID(kPassBasColorAmb)); }
Control *plPassMtl::GetOpacityController() { return fBasicPB->GetController(ParamID(kPassBasOpacity)); }
Control *plPassMtl::GetSpecularColorController() { return fBasicPB->GetController(ParamID(kPassBasSpecColor)); }
Control *plPassMtl::GetRuntimeColorController() { return fBasicPB->GetController(ParamID(kPassBasRunColor)); }
// Layer block
Texmap *plPassMtl::GetBaseLayer() { return fLayersPB->GetTexmap(kPassLayBase); }
int plPassMtl::GetTopLayerOn() { return fLayersPB->GetInt(kPassLayTopOn); }
Texmap *plPassMtl::GetTopLayer() { return fLayersPB->GetTexmap(kPassLayTop); }
int plPassMtl::GetLayerBlend() { return fLayersPB->GetInt(kPassLayBlend); }
int plPassMtl::GetOutputAlpha() { return fLayersPB->GetInt(kPassLayOutputAlpha); }
int plPassMtl::GetOutputBlend() { return fLayersPB->GetInt(kPassLayOutputBlend); }