OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
138 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: b53b6d588d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b53b6d588d'
${ noResults }
CWE-ou-minkata/Sources/Tools/MaxPlasmaLights/plRealTimeLightBase.cpp

2087 lines
67 KiB
Raw Blame History

/*==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 "HeadSpin.h"
#include "plRealTimeLightBase.h"
#include "iparamm2.h"
#include "resource.h"
#include "decomp.h"
#include "hsv.h"
#include "target.h"
#include "MaxPlasmaMtls/Layers/plLayerTex.h"
#include "MaxPlasmaMtls/Layers/plLayerTexBitmapPB.h"
static int GetTargetPoint(TimeValue t, INode *inode, Point3& p)
{
Matrix3 tmat;
if (inode->GetTargetTM(t,tmat))
{
p = tmat.GetTrans();
return 1;
}
else
return 0;
}
///////////////////////////////////////////////////////////////////////////////
//// plBaseLightProc Functions ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// This class provides the base functionality for all the dialog procs for
// the ParamBlock rollouts for each light
void plBaseLightProc::ILoadComboBox( HWND hComboBox, const char *names[] )
{
SendMessage(hComboBox, CB_RESETCONTENT, 0, 0);
for (int i = 0; names[i]; i++)
SendMessage(hComboBox, CB_ADDSTRING, 0, (LPARAM)names[i]);
SendMessage(hComboBox, CB_SETCURSEL, 0, 0);
}
void plBaseLightProc::IBuildLightMesh( plRTLightBase *base, float coneSize )
{
base->BuildSpotMesh( coneSize );
base->fMesh = base->spotMesh;
}
BOOL plBaseLightProc::DlgProc( TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
IParamBlock2 *pb = map->GetParamBlock();
plRTLightBase *gl = (plRTLightBase *) pb->GetOwner();
switch( msg )
{
case WM_INITDIALOG:
{
HWND DecayTypeCombo = GetDlgItem(hWnd, IDC_LIGHT_DECAY);
HWND ShadowStateCombo = GetDlgItem(hWnd, IDC_SHADOW_TYPE);
map->Invalidate(plRTLightBase::kProjMapTexButton);
}
break;
case WM_COMMAND:
break;
}
return false;
}
///////////////////////////////////////////////////////////////////////////////
//// plLightTexPBAccessor Class Functions /////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
plLightTexPBAccessor plLightTexPBAccessor::fAccessor;
void plLightTexPBAccessor::Set( PB2Value& val, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t )
{
plRTLightBase* Obj = (plRTLightBase*)owner;
IParamBlock2 *pb = Obj->fLightPB;
switch (id)
{
case plRTLightBase::kProjMapTexButton:
if (1) //(val.bm)->bm)
{
if (pb->GetMap())
pb->GetMap()->Invalidate(plRTLightBase::kProjMapTexButton);
//pb->SetValue(plRTLightBase::kProjMapTexButton, Obj->fIP->GetTime(), val.bm);
PBBitmap* ThisMap = val.bm;
Obj->SetProjMap(&ThisMap->bi);
break;
}
default:
break;
}
}
void plLightTexPBAccessor::Get( PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t, Interval &valid )
{
}
////////////////////////////////////////////////////////////
//
// Mouse creation callback class for this plug-in
class RTLightMouseCallBack : public CreateMouseCallBack
{
plRTLightBase *ob;
public:
int proc(ViewExp *vpt, int msg, int point, int flags, IPoint2 m, Matrix3 &mat);
void SetObj(plRTLightBase *obj) { ob = obj; }
};
static RTLightMouseCallBack gRTMouseCallback;
int RTLightMouseCallBack::proc(ViewExp *vpt, int msg, int point, int flags, IPoint2 m, Matrix3 &mat)
{
switch (msg)
{
case MOUSE_POINT:
case MOUSE_MOVE:
switch (point)
{
case 0:
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
break;
case 1:
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
if (msg == MOUSE_POINT)
return 0;
break;
}
break;
case MOUSE_ABORT:
return CREATE_ABORT;
}
return CREATE_CONTINUE;
}
static RTLightMouseCallBack sRTBaseLgtCreateCB;
CreateMouseCallBack* plRTLightBase::GetCreateMouseCallBack()
{
sRTBaseLgtCreateCB.SetObj(this);
return &sRTBaseLgtCreateCB;
}
/////////////////////////////////////////////////////////////////////////////
#if 0
plRTLightBase::plRTLightBase() : fIP(nil), fClassDesc(nil), fLightPB(nil)
{
fColor = Color(0.5f, 0.5f, 1.f);
}
#endif
void plRTLightBase::SetHSVColor(TimeValue t, Point3 &hsv)
{
DWORD rgb = HSVtoRGB ((int)(hsv[0]*255.0f), (int)(hsv[1]*255.0f), (int)(hsv[2]*255.0f));
Point3 temp = fLightPB->GetPoint3(kLightColor, t);
Point3 rgbf;
rgbf[0] = temp.x / 255.0f;
rgbf[1] = temp.y / 255.0f;
rgbf[2] = temp.z / 255.0f;
SetRGBColor(t, rgbf);
}
Point3 plRTLightBase::GetHSVColor(TimeValue t, Interval& b)
{
int h, s, v;
Point3 rgbf = GetRGBColor(t, b);
DWORD rgb = RGB((int)(rgbf[0]*255.0f), (int)(rgbf[1]*255.0f), (int)(rgbf[2]*255.0f));
RGBtoHSV (rgb, &h, &s, &v);
return Point3(h/255.0f, s/255.0f, v/255.0f);
}
#define FZ (0.0f)
#define SET_QUAD(face, v0, v1, v2, v3) \
staticMesh[RT_OMNI +1].faces[face].setVerts(v0, v1, v2); \
staticMesh[RT_OMNI +1].faces[face].setEdgeVisFlags(1,1,0); \
staticMesh[RT_OMNI +1].faces[face+1].setVerts(v0, v2, v3); \
staticMesh[RT_OMNI +1].faces[face+1].setEdgeVisFlags(0,1,1);
void plRTLightBase::BuildStaticMeshes()
{
if(!meshBuilt) {
int nverts = 6;
int nfaces = 8;
// Build a leetle octahedron
staticMesh[RT_OMNI].setNumVerts(nverts);
staticMesh[RT_OMNI].setNumFaces(nfaces);
float s = 8.0f;
staticMesh[RT_OMNI].setVert(0, Point3( FZ,FZ, -s));
staticMesh[RT_OMNI].setVert(1, Point3( s, FZ, FZ));
staticMesh[RT_OMNI].setVert(2, Point3( FZ, s, FZ));
staticMesh[RT_OMNI].setVert(3, Point3(-s, FZ, FZ));
staticMesh[RT_OMNI].setVert(4, Point3( FZ,-s, FZ));
staticMesh[RT_OMNI].setVert(5, Point3( FZ,FZ, s));
staticMesh[RT_OMNI].faces[0].setVerts(0,1,4);
staticMesh[RT_OMNI].faces[1].setVerts(0,4,3);
staticMesh[RT_OMNI].faces[2].setVerts(0,3,2);
staticMesh[RT_OMNI].faces[3].setVerts(0,2,1);
staticMesh[RT_OMNI].faces[4].setVerts(5,1,2);
staticMesh[RT_OMNI].faces[5].setVerts(5,2,3);
staticMesh[RT_OMNI].faces[6].setVerts(5,3,4);
staticMesh[RT_OMNI].faces[7].setVerts(5,4,1);
for (int i=0; i<nfaces; i++) {
staticMesh[RT_OMNI].faces[i].setSmGroup(i);
staticMesh[RT_OMNI].faces[i].setEdgeVisFlags(1,1,1);
}
staticMesh[RT_OMNI].buildNormals();
staticMesh[RT_OMNI].EnableEdgeList(1);
// Build an "arrow"
nverts = 13;
nfaces = 16;
staticMesh[RT_OMNI+1].setNumVerts(nverts);
staticMesh[RT_OMNI+1].setNumFaces(nfaces);
s = 4.0f;
float s4 = 16.0f;
staticMesh[RT_OMNI+1].setVert( 0, Point3( -s,-s, FZ));
staticMesh[RT_OMNI+1].setVert( 1, Point3( s,-s, FZ));
staticMesh[RT_OMNI+1].setVert( 2, Point3( s, s, FZ));
staticMesh[RT_OMNI+1].setVert( 3, Point3( -s, s, FZ));
staticMesh[RT_OMNI+1].setVert( 4, Point3( -s,-s, -s4));
staticMesh[RT_OMNI+1].setVert( 5, Point3( s,-s, -s4));
staticMesh[RT_OMNI+1].setVert( 6, Point3( s, s, -s4));
staticMesh[RT_OMNI+1].setVert( 7, Point3( -s, s, -s4));
s *= (float)2.0;
staticMesh[RT_OMNI+1].setVert( 8, Point3( -s,-s, -s4));
staticMesh[RT_OMNI+1].setVert( 9, Point3( s,-s, -s4));
staticMesh[RT_OMNI+1].setVert(10, Point3( s, s, -s4));
staticMesh[RT_OMNI+1].setVert(11, Point3( -s, s, -s4));
staticMesh[RT_OMNI+1].setVert(12, Point3( FZ,FZ, -s4-s));
SET_QUAD( 0, 1, 0, 4, 5);
SET_QUAD( 2, 0, 3, 7, 4);
SET_QUAD( 4, 3, 2, 6, 7);
SET_QUAD( 6, 2, 1, 5, 6);
SET_QUAD( 8, 0, 1, 2, 3);
SET_QUAD(10, 8, 9, 10, 11);
staticMesh[RT_OMNI+1].faces[12].setVerts(8,12,9);
staticMesh[RT_OMNI+1].faces[12].setEdgeVisFlags(1,1,1);
staticMesh[RT_OMNI+1].faces[13].setVerts(9,12,10);
staticMesh[RT_OMNI+1].faces[13].setEdgeVisFlags(1,1,1);
staticMesh[RT_OMNI+1].faces[14].setVerts(10,12,11);
staticMesh[RT_OMNI+1].faces[14].setEdgeVisFlags(1,1,1);
staticMesh[RT_OMNI+1].faces[15].setVerts(11,12,8);
staticMesh[RT_OMNI+1].faces[15].setEdgeVisFlags(1,1,1);
for (int i=0; i<nfaces; i++)
staticMesh[RT_OMNI+1].faces[i].setSmGroup(i);
staticMesh[RT_OMNI+1].buildNormals();
staticMesh[RT_OMNI+1].EnableEdgeList(1);
meshBuilt = 1;
}
}
void plRTLightBase::BuildSpotMesh(float coneSize)
{
// build a cone
if(coneSize < 0.0f)
return;
int nverts = 9;
int nfaces = 8;
spotMesh.setNumVerts(nverts);
spotMesh.setNumFaces(nfaces);
double radang = 3.1415926 * coneSize / 360.0;
float h = 20.0f; // hypotenuse
float d = -h * (float)cos(radang); // dist from origin to cone circle
float r = h * (float)sin(radang); // radius of cone circle
float s = 0.70711f * r; // sin(45) * r
spotMesh.setVert(0, Point3( FZ, FZ, FZ));
spotMesh.setVert(1, Point3( -r, FZ, d));
spotMesh.setVert(2, Point3( -s, -s, d));
spotMesh.setVert(3, Point3( FZ, -r, d));
spotMesh.setVert(4, Point3( s, -s, d));
spotMesh.setVert(5, Point3( r, FZ, d));
spotMesh.setVert(6, Point3( s, s, d));
spotMesh.setVert(7, Point3( FZ, r, d));
spotMesh.setVert(8, Point3( -s, s, d));
spotMesh.faces[0].setVerts(0,1,2);
spotMesh.faces[1].setVerts(0,2,3);
spotMesh.faces[2].setVerts(0,3,4);
spotMesh.faces[3].setVerts(0,4,5);
spotMesh.faces[4].setVerts(0,5,6);
spotMesh.faces[5].setVerts(0,6,7);
spotMesh.faces[6].setVerts(0,7,8);
spotMesh.faces[7].setVerts(0,8,1);
for (int i=0; i<nfaces; i++) {
spotMesh.faces[i].setSmGroup(i);
spotMesh.faces[i].setEdgeVisFlags(1,1,1);
}
spotMesh.buildNormals();
spotMesh.EnableEdgeList(1);
//fMesh = spotMesh;
}
plRTLightBase::~plRTLightBase()
{
DeleteAllRefsFromMe();
fLightPB = NULL;
if( fTex )
delete fTex;
}
IParamBlock2* plRTLightBase::GetParamBlock2()
{
return fLightPB;
}
IParamBlock2* plRTLightBase::GetParamBlockByID( short id )
{
if( id == fLightPB->ID() )
return fLightPB;
else
return nil;
}
IParamBlock2 *plRTLightBase::GetParamBlock( int i )
{
switch( i )
{
case 0: return fLightPB;
default: return nil;
}
}
// So our animatables will show up in the trackview
int plRTLightBase::NumSubs()
{
return 1;
}
Animatable *plRTLightBase::SubAnim(int i)
{
return (Animatable *)fLightPB;
switch(i)
{
/* kRefProjMap,
kRefShadowProjMap,
kRefShadowType,
kRefOmniLight,
kRefSpotLight,
kRefTSpotLight,
kRefDirLight,
kRefTDirLight
*/
case kRefOmniLight:
case kRefSpotLight:
case kRefTSpotLight:
case kRefDirLight:
case kRefTDirLight:
case kRefProjDirLight:
return (Animatable*)fLightPB;
case kRefProjMap:
Texmap* MyMap;
return (Animatable*) fLightPB->GetValue(kProjMapTexButton, 0, MyMap, FOREVER);
case kRefShadowType:
return NULL;
default: return NULL;
}
//return (Animatable*) fLightPB;
}
TSTR plRTLightBase::SubAnimName(int i)
{
return fLightPB->GetLocalName();
switch(i)
{
case kRefOmniLight:return _T("");
case kRefSpotLight: return TSTR(GetString(IDS_DB_FSPOT));
case kRefTSpotLight:return _T("");
case kRefDirLight:return _T("");
case kRefTDirLight:return _T("");
case kRefProjMap: return TSTR(GetString(IDS_DS_PROJMAP));
case kRefShadowType: return _T("");
default: return _T("");
/* case PBLOCK_REF: return TSTR(GetString(IDS_RB_PARAMETERS));
case PROJMAP_REF: return TSTR(GetString(IDS_DS_PROJMAP));
case SHADPROJMAP_REF: return TSTR(GetString(IDS_DS_SHADPROJMAP));
case SHADTYPE_REF: return TSTR(GetString(IDS_DS_SHAD_GEN));
case EMITTER_REF:
if ( IsCompatibleRenderer ())
return TSTR(GetString(IDS_EMITTER));
else
return _T("");
default: return _T("");
*/
}
}
#if 0
RefTargetHandle plRTSpotLight::Clone(RemapDir &remap)
{
plRTLightBase *obj = TRACKED_NEW plRTSpotLight;
obj->GetParamBlock2->SetValue(kLightOn, t, fLightPB->GetInt(kLightOn, t));
// obj->fLightPB->SetValue(kLightType, t, fLightPB->GetInt(kLightType, t));
obj->fLightPB->SetValue(kLightColor, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kCastShadows, t, fLightPB->GetInt(kLightOn, t));
//obj->fLightPB->SetValue(kContrast, t, fLightPB->GetInt(kLightOn, t));
//obj->fLightPB->SetValue(kDiffSoft, t, fLightPB->GetInt(kLightOn, t));
//obj->fLightPB->SetValue(kDiffOn, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kSpec, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kSpecularColorSwatch, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kIntensity, t, fLightPB->GetInt(kLightOn, t));
if( IHasAttenuation() )
{
obj->fLightPB->SetValue(kUseAttenuationBool, t, fLightPB->GetInt(kLightType, t));
obj->fLightPB->SetValue(kAttenMaxFalloffEdit, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kAttenTypeRadio, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kShowConeBool, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kHotSpot, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kAttenMaxFalloffEdit, fLightPB->GetInt(kLightType, t));
obj->fLightPB->SetValue(kFallOff, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kUseProjectorBool, t, fLightPB->GetInt(kLightOn, t));
obj->fLightPB->SetValue(kProjMapTexButton, t, fLightPB->GetInt(kLightOn, t));
}
obj->ReplaceReference(kRefSpotLight,fLightPB->Clone(remap));
/*
GeneralLight* newob = TRACKED_NEW GeneralLight(type);
newob->enable = enable;
newob->coneDisplay = coneDisplay;
newob->useLight = useLight;
newob->attenDisplay = attenDisplay;
newob->useAtten = useAtten;
newob->useAttenNear = useAttenNear;
newob->attenNearDisplay = attenNearDisplay;
newob->decayDisplay = decayDisplay;
newob->shape = shape;
newob->shadow = shadow;
newob->shadowType = shadowType;
newob->overshoot = overshoot;
newob->projector = projector;
newob->absMapBias = absMapBias;
newob->exclList = exclList;
newob->softenDiffuse = softenDiffuse;
newob->affectDiffuse = affectDiffuse;
newob->affectSpecular = affectSpecular;
newob->ambientOnly = ambientOnly;
newob->decayType = decayType;
newob->atmosShadows = atmosShadows;
newob->atmosOpacity = atmosOpacity;
newob->atmosColAmt = atmosColAmt;
newob->ReplaceReference(PBLOCK_REF,pblock->Clone(remap));
if (projMap) newob->ReplaceReference(PROJMAP_REF,projMap->Clone(remap));
if (shadProjMap) newob->ReplaceReference(SHADPROJMAP_REF,shadProjMap->Clone(remap));
if (shadType) newob->ReplaceReference(SHADTYPE_REF,shadType->Clone(remap));
if (emitter) newob->ReplaceReference(EMITTER_REF ,emitter->Clone(remap));
BaseClone(this, newob, remap);
return(newob);
*/
//plRTLightBase *obj = (plRTLightBase*) fClassDesc->Create(false);
//obj->ReplaceReference(kRefComp, fLightPB->Clone(remap));
return obj;
}
#endif
void plRTLightBase::FreeCaches()
{
// fMesh.FreeAll();
}
void plRTLightBase::BoxCircle(TimeValue t, float r, float d, Box3& box, int extraPt, Matrix3 *tm)
{
Point3 q[3*NUM_CIRC_PTS];
int npts;
float asp;
if ( 1 /*Circle Object*/) { npts = NUM_CIRC_PTS+extraPt; asp = -1.0f; }
else { npts = 4+extraPt; asp = -1.0; }
GetConePoints(t, asp , r, d, q);
box.IncludePoints(q,npts,tm);
}
void plRTLightBase::BoxDirPoints(TimeValue t, float angle, float dist, Box3 &box, Matrix3 *tm)
{
int npts;
Point3 q[3*NUM_CIRC_PTS];
npts = 1 /*Circle Object*/? GetCirXPoints(t,angle,dist,q): GetRectXPoints(t,angle,dist,q);
box.IncludePoints(q,npts,tm);
}
void plRTLightBase::BoxPoints(TimeValue t, float angle, float dist, Box3 &box, Matrix3 *tm)
{
if (IsDir())
BoxCircle(t, angle, dist, box, 0,tm);
else
BoxDirPoints(t, angle, dist, box, tm);
}
void plRTLightBase::BoxLight(TimeValue t, INode *inode, Box3& box, Matrix3 *tm)
{
Point3 pt;
float d;
if (GetTargetPoint(t, inode, pt))
{
Point3 loc = inode->GetObjectTM(t).GetTrans();
d = FLength(loc - pt) / FLength(inode->GetObjectTM(t).GetRow(2));
box += tm? (*tm)*Point3(0.0f, 0.0f, -d): Point3(0.0f, 0.0f, -d);
}
else
{
d = GetTDist(t);
// if(fLightPB->GetInt(kLightType) == RT_FREE_DIR)
// d = GetFallsize(t);
if(IsSpot())
box += tm? (*tm)*Point3(0.0f, 0.0f, -d): Point3(0.0f, 0.0f, -d);
if(IsDir())
{
d = GetFallsize(t);
box += tm? (*tm)*Point3(0.0f, 0.0f, -d): Point3(0.0f, 0.0f, -d);
}
}
if( this->ClassID() == RTSPOT_LIGHT_CLASSID )
// if (fLightPB->GetInt(kLightType) == RT_FREE_SPOT || fLightPB->GetInt(kLightType) == RT_TARGET_SPOT)
if((fLightPB->GetInt(kShowConeBool,t)) || (extDispFlags & EXT_DISP_ONLY_SELECTED))
{
float rad = MaxF(GetHotspot(t), GetFallsize(t));
if (IsDir())
BoxCircle(t,rad,0.0f,box,1,tm);
BoxCircle(t,rad,d,box,1,tm);
}
if( this->ClassID() == RTDIR_LIGHT_CLASSID
|| this->ClassID() == RTPDIR_LIGHT_CLASSID )
// if (fLightPB->GetInt(kLightType) == RT_FREE_DIR || fLightPB->GetInt(kLightType) == RT_TARGET_DIR)
if((extDispFlags & EXT_DISP_ONLY_SELECTED))
{
float rad = MaxF(GetHotspot(t), GetFallsize(t));
if (IsDir())
BoxCircle(t,rad,0.0f,box,1,tm);
BoxCircle(t,rad,2.82841*GetFallsize(t),box,1,tm); //hack, hack. Do 2root2 at corners...
}
BOOL dispAtten = false;
BOOL dispAttenNear = false;
BOOL dispDecay = false;
if( this->ClassID() == RTOMNI_LIGHT_CLASSID || this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
dispAtten = fLightPB->GetInt(kUseAttenuationBool,t);
dispAttenNear = 0; //attenNearDisplay;
dispDecay = (GetDecayType()&&(extDispFlags & EXT_DISP_ONLY_SELECTED));
}
if( dispAtten || dispDecay)
{
if( this->ClassID() == RTOMNI_LIGHT_CLASSID )
{
Point3 q[3*NUM_CIRC_PTS];
float rad = 0;
if (dispAtten)
rad = MaxF(GetAtten(t, ATTEN_START), GetAtten(t, ATTEN_END));
if (dispDecay) rad = MaxF(rad,0.0/*GetDecayRadius(t)*/);
GetAttenPoints(t, rad, q);
box.IncludePoints(q,3*NUM_CIRC_PTS,tm);
}
if( this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
if (dispAtten)
{
BoxPoints(t, GetFallsize(t), GetAtten(t,ATTEN_END), box, tm);
BoxPoints(t, GetFallsize(t), GetAtten(t,ATTEN_START), box, tm);
}
if (dispDecay)
BoxPoints(t, GetFallsize(t), 0.0/*GetDecayRadius(t)*/, box, tm);
}
}
}
int plRTLightBase::GetRectXPoints(TimeValue t, float angle, float dist, Point3 *q)
{
int i;
if(dist==0.0f) dist = .00001f;
float ang = DegToRad(angle)/2.0f;
float da,sn,cs,x,y,z,a;
float aspect = GetAspect(t);
float w = dist * (float)tan(ang) * (float)sqrt((double)aspect);
float h = w/aspect;
float wang = (float)atan(w/dist);
float hang = (float)atan(h/dist);
float aw = float(atan(w/dist)*cos(hang)); // half-angle of top and bottom arcs
float ah = float(atan(h/dist)*cos(wang)); // half-angle of left and right arcs
int j = 0;
// draw horizontal and vertical center lines
da = wang/float(NUM_HALF_ARC);
for(i = -NUM_HALF_ARC, a = -wang; i<= NUM_HALF_ARC; i++, a+=da)
q[j++] = Point3(dist*(float)sin(a), 0.0f, -dist*(float)cos(a));
da = hang/float(NUM_HALF_ARC);
for(i = -NUM_HALF_ARC, a = -hang; i<= NUM_HALF_ARC; i++, a+=da)
q[j++] = Point3(0.0f, dist*(float)sin(a), -dist*(float)cos(a));
// draw top and bottom arcs
da = aw/float(NUM_HALF_ARC);
sn = (float)sin(hang);
cs = (float)cos(hang);
for (i = -NUM_HALF_ARC, a = -aw; i<= NUM_HALF_ARC; i++, a+=da)
{
x = dist*(float)sin(a);
z = -dist*(float)cos(a);
q[j] = Point3(x, z*sn, z*cs);
q[j+NUM_ARC_PTS] = Point3(x,-z*sn, z*cs);
j++;
}
j+= NUM_ARC_PTS;
// draw left and right arcs
da = ah/float(NUM_HALF_ARC);
sn = (float)sin(wang);
cs = (float)cos(wang);
for (i = -NUM_HALF_ARC, a = -ah; i<= NUM_HALF_ARC; i++, a+=da)
{
y = dist*(float)sin(a);
z = -dist*(float)cos(a);
q[j] = Point3( z*sn, y, z*cs);
q[j+NUM_ARC_PTS] = Point3(-z*sn, y, z*cs);
j++;
}
return 6*NUM_ARC_PTS;
}
int plRTLightBase::GetCirXPoints(TimeValue t, float angle, float dist, Point3 *q)
{
int i;
float ang = DegToRad(angle)/2.0f;
float da = ang/float(NUM_HALF_ARC);
// first draw circle:
float d = dist*(float)cos(ang);
GetConePoints(t, -1.0f, angle, d, q);
int j=NUM_CIRC_PTS;
// then draw Arc X
float a = -ang;
for(i = -NUM_HALF_ARC; i<= NUM_HALF_ARC; i++, a+=da)
q[j++] = Point3(0.0f, dist*(float)sin(a), -dist*(float)cos(a));
a = -ang;
for(i = -NUM_HALF_ARC; i<= NUM_HALF_ARC; i++, a+=da)
q[j++] = Point3(dist*(float)sin(a), 0.0f, -dist*(float)cos(a));
return NUM_CIRC_PTS + 2*NUM_ARC_PTS;
}
void plRTLightBase::DrawX(TimeValue t, float asp, int npts, float dist, GraphicsWindow *gw, int indx)
{
Point3 q[3*NUM_CIRC_PTS+1];
Point3 u[2];
GetConePoints(t, asp, GetFallsize(t), dist, q);
gw->polyline(npts, q,NULL, NULL, TRUE, NULL);
u[0] = q[0]; u[1] = q[2*indx];
gw->polyline(2, u,NULL, NULL, FALSE, NULL);
u[0] = q[indx]; u[1] = q[3*indx];
gw->polyline(2, u,NULL, NULL, FALSE, NULL);
}
void plRTLightBase::GetAttenPoints(TimeValue t, float rad, Point3 *q)
{
double a;
float sn, cs;
for(int i = 0; i < NUM_CIRC_PTS; i++)
{
a = (double)i * 2.0 * 3.1415926 / (double)NUM_CIRC_PTS;
sn = rad * (float)sin(a);
cs = rad * (float)cos(a);
q[i+0*NUM_CIRC_PTS] = Point3(sn, cs, 0.0f);
q[i+1*NUM_CIRC_PTS] = Point3(sn, 0.0f, cs);
q[i+2*NUM_CIRC_PTS] = Point3(0.0f, sn, cs);
}
}
// Draw warped rectangle
void plRTLightBase::DrawWarpRect(TimeValue t, GraphicsWindow *gw, float angle, float dist, Point3 *q)
{
GetRectXPoints(t, angle,dist,q);
for (int i=0; i<6; i++)
gw->polyline(NUM_ARC_PTS, q+i*NUM_ARC_PTS,NULL, NULL, FALSE, NULL);
}
void plRTLightBase::DrawCircleX(TimeValue t, GraphicsWindow *gw, float angle, float dist, Point3 *q)
{
GetCirXPoints(t, angle,dist,q);
gw->polyline(NUM_CIRC_PTS, q,NULL, NULL, TRUE, NULL); // circle
gw->polyline(NUM_ARC_PTS, q+NUM_CIRC_PTS,NULL, NULL, FALSE, NULL); // vert arc
gw->polyline(NUM_ARC_PTS, q+NUM_CIRC_PTS+NUM_ARC_PTS,NULL, NULL, FALSE, NULL); // horiz arc
}
void plRTLightBase::DrawSphereArcs(TimeValue t, GraphicsWindow *gw, float r, Point3 *q)
{
GetAttenPoints(t, r, q);
gw->polyline(NUM_CIRC_PTS, q, NULL, NULL, TRUE, NULL);
gw->polyline(NUM_CIRC_PTS, q+NUM_CIRC_PTS, NULL, NULL, TRUE, NULL);
gw->polyline(NUM_CIRC_PTS, q+2*NUM_CIRC_PTS,NULL, NULL, TRUE, NULL);
}
//
void plRTLightBase::DrawAttenCirOrRect(TimeValue t, GraphicsWindow *gw, float dist, BOOL froze, int uicol)
{
if (!froze) gw->setColor( LINE_COLOR, GetUIColor(uicol));
if (IsDir())
{
int npts,indx;
float asp;
npts = NUM_CIRC_PTS; asp = -1.0f; indx = SEG_INDEX;
DrawX(t, asp, npts, dist, gw, indx);
}
else
{
Point3 q[3*NUM_CIRC_PTS+1];
if( this->ClassID() == RTOMNI_LIGHT_CLASSID )
DrawSphereArcs(t, gw, dist, q);
else
DrawCircleX(t, gw, GetFallsize(t),dist,q);
}
}
int plRTLightBase::DrawAtten(TimeValue t, INode *inode, GraphicsWindow *gw)
{
BOOL dispAtten = false;
BOOL dispDecay = false;
if( this->ClassID() == RTOMNI_LIGHT_CLASSID || this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
dispAtten = (fLightPB->GetInt(kUseAttenuationBool,t) && (extDispFlags & EXT_DISP_ONLY_SELECTED));
//BOOL dispAttenNear = (fLightPB->GetInt(kUseNearAtten) && (extDispFlags & EXT_DISP_ONLY_SELECTED))?TRUE:fLightPB->GetInt(kShowFarAttenRanges);
dispDecay = (GetDecayType() && (extDispFlags & EXT_DISP_ONLY_SELECTED));
}
if (dispAtten || dispDecay)
{
Matrix3 tm = inode->GetObjectTM(t);
gw->setTransform(tm);
BOOL froze = inode->IsFrozen() && !inode->Dependent();
if (dispAtten)
{
DrawAttenCirOrRect(t, gw, GetAtten(t,ATTEN_START), froze, COLOR_START_RANGE);
DrawAttenCirOrRect(t, gw, GetAtten(t,ATTEN_END), froze, COLOR_END_RANGE);
}
if (dispDecay)
{
DrawAttenCirOrRect(t, gw, 0.0 /*DecayRadius() Stuff here */, froze, COLOR_DECAY_RADIUS);
}
}
return 0;
}
void plRTLightBase::GetLocalBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box)
{
//BuildMeshes(t);
//box = fMesh.getBoundingBox();
// int nv;
// Matrix3 tm;
// GetMat(t, node,vpt,tm);
// Point3 loc = tm.GetTrans();
// nv = fMesh.getNumVerts();
// box.Init();
// if(!(extDispFlags & EXT_DISP_ZOOM_EXT))
// box.IncludePoints(fMesh.verts,nv,&tm);
// else
// box += loc;
// tm = node->GetObjectTM(t);
// BoxLight(t, node, box, &tm);
Point3 loc = node->GetObjectTM(t).GetTrans();
float scaleFactor = vpt->NonScalingObjectSize()*vpt->GetVPWorldWidth(loc) / 360.0f;
box = fMesh.getBoundingBox();
box.Scale(scaleFactor);
BoxLight(t, node, box, NULL);
}
/*
RefTargetHandle Clone(RemapDir &remap = NoRemap())
{
plRTLightBase* newOb = TRACKED_NEW plRTLightBase;
newOb->fLightPB->SetValue(kLightOn, 0, this->fLightPB->GetInt(kLightOn, 0));
newOb->fLightPB->SetValue(kLightColor, 0, this->fLightPB->GetValue(kLightColor, 0));
newOb->fLightPB->SetValue(kLightExclude, 0, this->fLightPB->GetValue(kLightExclude, 0));
newOb->fLightPB->SetValue(kRed, 0, this->fLightPB->GetInt(kRed, 0));
newOb->fLightPB->SetValue(kGreen, 0, this->fLightPB->GetInt(kGreen, 0));
newOb->fLightPB->SetValue(kBlue, 0, this->fLightPB->GetInt(kBlue, 0));
newOb->fLightPB->SetValue(kHue, 0, this->fLightPB->GetInt(kHue, 0));
newOb->fLightPB->SetValue(kSat, 0, this->fLightPB->GetInt(kSat, 0));
newOb->fLightPB->SetValue(kVal, 0, this->fLightPB->GetInt(kVal, 0));
newOb->fLightPB->SetValue(kIntensity, 0, this->fLightPB->GetFloat(kIntensity, 0));
newOb->fLightPB->SetValue(kContrast, 0, this->fLightPB->GetFloat(kContrast, 0));
newOb->fLightPB->SetValue(kDiffSoft, 0, this->fLightPB->GetFloat(kDiffSoft, 0));
newOb->fLightPB->SetValue(kDiffOn, 0, this->fLightPB->GetInt(kDiffOn, 0));
newOb->fLightPB->SetValue(kStartAttenNear, 0, this->fLightPB->GetFloat(kStartAttenNear, 0));
newOb->fLightPB->SetValue(kAmbiOnly, 0, this->fLightPB->GetInt(kAmbiOnly, 0));
newOb->fLightPB->SetValue(kEndAttenNear, 0, this->fLightPB->GetFloat(kEndAttenNear, 0));
newOb->fLightPB->SetValue(kUseNearAtten, 0, this->fLightPB->GetInt(kUseNearAtten, 0));
newOb->fLightPB->SetValue(kShowNearAttenRanges, 0, this->fLightPB->GetInt(kShowNearAttenRanges, 0));
newOb->fLightPB->SetValue(kStartAttenFar, 0, this->fLightPB->GetFloat(kStartAttenFar, 0));
newOb->fLightPB->SetValue(kEndAttenFar, 0, this->fLightPB->GetFloat(kEndAttenFar, 0));
newOb->fLightPB->SetValue(kUseFarAtten, 0, this->fLightPB->GetInt(kUseFarAtten, 0));
newOb->fLightPB->SetValue(kShowFarAttenRanges, 0, this->fLightPB->GetInt(kShowFarAttenRanges, 0));
newOb->fLightPB->SetValue(kLightDecay, 0, this->fLightPB->GetInt(kLightDecay, 0));
newOb->fLightPB->SetValue(kRed, 0, this->fLightPB->GetInt(kRed, 0));
newOb->fLightPB->SetValue(kGreen, 0, this->fLightPB->GetInt(kGreen, 0));
newOb->fLightPB->SetValue(kBlue, 0, this->fLightPB->GetInt(kBlue, 0));
newOb->fLightPB->SetValue(kHue, 0, this->fLightPB->GetInt(kHue, 0));
newOb->fLightPB->SetValue(kSat, 0, this->fLightPB->GetInt(kSat, 0));
newOb->fLightPB->SetValue(kVal, 0, this->fLightPB->GetInt(kVal, 0));
newOb->fLightPB->SetValue(kIntensity, 0, this->fLightPB->GetFloat(kIntensity, 0));
newOb->fLightPB->SetValue(kContrast, 0, this->fLightPB->GetFloat(kContrast, 0));
newOb->fLightPB->SetValue(kDiffSoft, 0, this->fLightPB->GetFloat(kDiffSoft, 0));
newOb->fLightPB->SetValue(kDiffOn, 0, this->fLightPB->GetInt(kDiffOn, 0));
newOb->fLightPB->SetValue(kStartAttenNear, 0, this->fLightPB->GetFloat(kStartAttenNear, 0));
newOb->fLightPB->SetValue(kAmbiOnly, 0, this->fLightPB->GetInt(kAmbiOnly, 0));
newOb->fLightPB->SetValue(kEndAttenNear, 0, this->fLightPB->GetFloat(kEndAttenNear, 0));
newOb->fLightPB->SetValue(kUseNearAtten, 0, this->fLightPB->GetInt(kUseNearAtten, 0));
newOb->fLightPB->SetValue(kShowNearAttenRanges, 0, this->fLightPB->GetInt(kShowNearAttenRanges, 0));
newOb->fLightPB->SetValue(kStartAttenFar, 0, this->fLightPB->GetFloat(kStartAttenFar, 0));
newOb->fLightPB->SetValue(kEndAttenFar, 0, this->fLightPB->GetFloat(kEndAttenFar, 0));
*/
/*
kLightType, //Inserted in v1
kLightOn, //Inserted in v1
kLightColor, //Inserted in v1
kLightExclude, //Inserted in v1
kRed, //Inserted in v1
kGreen, //Inserted in v1
kBlue, //Inserted in v1
kHue, //Inserted in v1
kSat, //Inserted in v1
kVal, //Inserted in v1
kIntensity, //Inserted in v1
kContrast, //Inserted in v1
kDiffSoft, //Inserted in v1
kDiffOn, //Inserted in v1
kSpec, //Inserted in v1
kAmbiOnly, //Inserted in v1
kStartAttenNear, //Inserted in v1
kEndAttenNear, //Inserted in v1
kUseNearAtten, //Inserted in v1
kShowNearAttenRanges,//Inserted in v1
kStartAttenFar, //Inserted in v1
kEndAttenFar, //Inserted in v1
kUseFarAtten, //Inserted in v1
kShowFarAttenRanges, //Inserted in v1
kLightDecay, //Inserted in v1
kDecayEdit, //Inserted in v1
kShowDecay, //Inserted in v1
kUseProjectBool, //Inserted in v1
kProjMapTexButton, //Inserted in v1
kShowConeBool, //Inserted in v1
kOvershootBool, //Inserted in v1
kHotSpot, //Inserted in v1
kFallOff, //Inserted in v1
kLightShapeRadio, //Inserted in v1
kAspect, //Inserted in v1
kUseProjectorBool, //Inserted in v1
kProjMapTexButton2, //Inserted in v1
kTargetDist //Inserted in v1
GeneralLight* newob = TRACKED_NEW GeneralLight(type);
newob->enable = enable;
newob->coneDisplay = coneDisplay;
newob->useLight = useLight;
newob->attenDisplay = attenDisplay;
newob->useAtten = useAtten;
newob->useAttenNear = useAttenNear;
newob->attenNearDisplay = attenNearDisplay;
newob->decayDisplay = decayDisplay;
newob->shape = shape;
newob->shadow = shadow;
newob->shadowType = shadowType;
newob->overshoot = overshoot;
newob->projector = projector;
newob->absMapBias = absMapBias;
newob->exclList = exclList;
newob->softenDiffuse = softenDiffuse;
newob->affectDiffuse = affectDiffuse;
newob->affectSpecular = affectSpecular;
newob->ambientOnly = ambientOnly;
newob->decayType = decayType;
newob->atmosShadows = atmosShadows;
newob->atmosOpacity = atmosOpacity;
newob->atmosColAmt = atmosColAmt;
newob->ReplaceReference(PBLOCK_REF,pblock->Clone(remap));
if (projMap) newob->ReplaceReference(PROJMAP_REF,projMap->Clone(remap));
if (shadProjMap) newob->ReplaceReference(SHADPROJMAP_REF,shadProjMap->Clone(remap));
if (shadType) newob->ReplaceReference(SHADTYPE_REF,shadType->Clone(remap));
if (emitter) newob->ReplaceReference(EMITTER_REF ,emitter->Clone(remap));
BaseClone(this, newob, remap);
return(newob);
}
*/
//}
void plRTLightBase::GetWorldBoundBox(TimeValue t, INode *node, ViewExp *vpt, Box3 &box)
{
GetLocalBoundBox( t, node, vpt, box );
box = box * node->GetObjectTM( t );
}
void plRTLightBase::GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm, BOOL useSel )
{
box = fMesh.getBoundingBox(tm);
}
int plRTLightBase::Display(TimeValue t, INode *node, ViewExp *vpt, int flags)
{
Matrix3 m;
// if (!enable)
// return 0;
GraphicsWindow *gw = vpt->getGW();
GetMat(t,node,vpt,m);
gw->setTransform(m);
DWORD rlim = gw->getRndLimits();
gw->setRndLimits(GW_WIREFRAME|GW_BACKCULL|(gw->getRndMode() & GW_Z_BUFFER));
if (node->Selected())
gw->setColor( LINE_COLOR, GetSelColor());
else if(!node->IsFrozen() && !node->Dependent())
{
if(fLightPB->GetInt(kLightOn))
gw->setColor( LINE_COLOR, GetUIColor(COLOR_LIGHT_OBJ));
// I un-commented this line DS 6/11/99
else
gw->setColor( LINE_COLOR, 0.0f, 0.0f, 0.0f);
}
fMesh.render( gw, gw->getMaterial(),
(flags&USE_DAMAGE_RECT) ? &vpt->GetDammageRect() : NULL, COMP_ALL);
DrawConeAndLine(t, node, gw, 1);
// DrawAtten(t, node, gw);
gw->setRndLimits(rlim);
return 0;
}
static void RemoveScaling(Matrix3 &tm)
{
AffineParts ap;
decomp_affine(tm, &ap);
tm.IdentityMatrix();
tm.SetRotate(ap.q);
tm.SetTrans(ap.t);
}
void plRTLightBase::GetMat(TimeValue t, INode* inode, ViewExp *vpt, Matrix3& tm)
{
tm = inode->GetObjectTM(t);
// tm.NoScale();
RemoveScaling(tm);
float scaleFactor = vpt->NonScalingObjectSize()*vpt->GetVPWorldWidth(tm.GetTrans())/(float)360.0;
tm.Scale(Point3(scaleFactor,scaleFactor,scaleFactor));
}
void plRTLightBase::GetConePoints(TimeValue t, float aspect, float angle, float dist, Point3 *q)
{
float ta = (float)tan(0.5*DegToRad(angle));
if(1 /*fLightPB->GetFloat(kAspect, t) <= 0.0f*/)
{
// CIRCULAR
float rad = dist * ta;
double a;
if(IsDir())
rad = angle;
int i;
for(i = 0; i < NUM_CIRC_PTS; i++) {
a = (double)i * 2.0 * 3.1415926 / (double)NUM_CIRC_PTS;
q[i] = Point3(rad*(float)sin(a), rad*(float)cos(a), -dist);
}
q[i] = q[0] + Point3(0.0f, 15.0f, 0.0f);
}
else
{
// RECTANGULAR
float w = IsDir()? angle : dist * ta * (float)sqrt((double)aspect);
float h = w / aspect;
q[0] = Point3( w, h,-dist);
q[1] = Point3(-w, h,-dist);
q[2] = Point3(-w,-h,-dist);
q[3] = Point3( w,-h,-dist);
q[4] = Point3( 0.0f, h+15.0f, -dist);
q[5] = Point3( 0.0f, h, -dist);
}
}
#define HOTCONE 0
#define FALLCONE 1
void plRTLightBase::DrawCone(TimeValue t, GraphicsWindow *gw, float dist)
{
Point3 q[NUM_CIRC_PTS+1], u[3];
int dirLight = IsDir();
int i;
BOOL dispAtten = false;
BOOL dispDecay = false;
if( this->ClassID() == RTOMNI_LIGHT_CLASSID || this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
dispAtten = (fLightPB->GetInt(kUseAttenuationBool, t) && (extDispFlags & EXT_DISP_ONLY_SELECTED));//attenDisplay;
dispDecay = (/*fLightPB->GetInt(kAttenTypeRadio, t)*/GetDecayType() && (extDispFlags & EXT_DISP_ONLY_SELECTED));
}
if(!IsDir())
GetConePoints(t, -1.0f, GetHotspot(t), dist, q);
else
GetConePoints(t, -1.0f, 20.0, dist, q);
gw->setColor( LINE_COLOR, GetUIColor(COLOR_HOTSPOT));
if(1 /*Circular Hack*/) {
// CIRCULAR
if(GetHotspot(t) >= GetFallsize(t))
{
// draw (far) hotspot circle
u[0] = q[0];
u[1] = q[NUM_CIRC_PTS];
gw->polyline( 2, u, NULL, NULL, FALSE, NULL);
}
gw->polyline(NUM_CIRC_PTS, q, NULL, NULL, TRUE, NULL);
if (dirLight)
{
// draw 4 axial hotspot lines
for (i = 0; i < NUM_CIRC_PTS; i += SEG_INDEX)
{
u[0] = q[i]; u[1] = q[i]; u[1].z += dist;
gw->polyline( 2, u, NULL, NULL, FALSE, NULL );
}
GetConePoints(t, -1.0f, 20/*GetHotspot(t)*/, 0.0f, q);
// draw (near) hotspot circle
gw->polyline(NUM_CIRC_PTS, q, NULL, NULL, TRUE, NULL);
}
else
{
// draw 4 axial lines
u[0] = Point3(0,0,0);
for (i = 0; i < NUM_CIRC_PTS; i += SEG_INDEX)
{
u[1] = q[i];
gw->polyline( 2, u, NULL, NULL, FALSE, NULL );
}
}
if(!IsDir())
GetConePoints(t, -1.0f, GetFallsize(t), dist, q);
else
GetConePoints(t, -1.0f, 200.0, dist, q);
gw->setColor( LINE_COLOR, GetUIColor(COLOR_FALLOFF));
if(GetHotspot(t) < GetFallsize(t))
{
// draw (far) fallsize circle
u[0] = q[0]; u[1] = q[NUM_CIRC_PTS];
gw->polyline( 2, u, NULL, NULL, FALSE, NULL);
u[0] = Point3(0,0,0);
}
gw->polyline(NUM_CIRC_PTS, q, NULL, NULL, TRUE, NULL);
if (dirLight)
{
float dfar = q[0].z;
float dnear = 0.0f;
if (dispAtten)
{
dfar = MinF(-GetAtten(t,ATTEN_END),dfar);
/// dnear = MaxF(-GetAtten(t,ATTEN_START),dnear);
}
if (dispDecay) {
dfar = MinF(/*-GetDecayRadius(t)*/ 0.0,dfar);
}
// draw axial fallsize lines
for (i = 0; i < NUM_CIRC_PTS; i += SEG_INDEX)
{
u[0] = q[i]; u[0].z = dfar; u[1] = q[i]; u[1].z = dnear;
gw->polyline( 2, u, NULL, NULL, FALSE, NULL );
}
GetConePoints(t, -1.0f, 10000.0, 0.0f, q);
// draw (near) fallsize circle
gw->polyline(NUM_CIRC_PTS, q, NULL, NULL, TRUE, NULL);
}
else
{
float cs = (float)cos(DegToRad(GetFallsize(t)*0.5f));
float dfar = q[0].z;
if (dispAtten)
dfar = MinF(-cs*GetAtten(t,ATTEN_END),dfar);
if (dispDecay)
dfar = MinF(/*-cs*GetDecayRadius(t)*/0.0,dfar);
for (i = 0; i < NUM_CIRC_PTS; i += SEG_INDEX)
{
u[1] = -q[i]*dfar/dist;
gw->polyline( 2, u, NULL, NULL, FALSE, NULL );
}
}
}
}
int plRTLightBase::DrawConeAndLine(TimeValue t, INode* inode, GraphicsWindow *gw, int drawing )
{
if(!IsSpot() && !IsDir())
return 0;
Matrix3 tm = inode->GetObjectTM(t);
gw->setTransform(tm);
gw->clearHitCode();
if( 0 )
{
Point3 pt,v[3];
if (GetTargetPoint(t, inode, pt))
{
float den = FLength(tm.GetRow(2));
float dist = (den!=0) ? FLength(tm.GetTrans()-pt) / den : 0.0f;
fLightPB->SetValue(kAttenMaxFalloffEdit, t, dist);
//fLightPB->SetValue(kTargetDist, t, dist);
//if (hSpotLight&&(currentEditLight==this)) {
// TCHAR buf[40];
// _stprintf(buf,_T("%0.3f"),targDist);
// SetWindowText(GetDlgItem(hSpotLight,IDC_TARG_DISTANCE),buf);
// }
if ((drawing != -1) && (fLightPB->GetInt(kShowConeBool, t) || (extDispFlags & EXT_DISP_ONLY_SELECTED)))
DrawCone(t, gw, dist);
if(!inode->IsFrozen() && !inode->Dependent())
gw->setColor( LINE_COLOR, GetUIColor(COLOR_TARGET_LINE));
v[0] = Point3(0,0,0);
v[1] = Point3(0.0f, 0.0f, (drawing == -1)? (-0.9f * dist): -dist);
gw->polyline( 2, v, NULL, NULL, FALSE, NULL );
}
}
else if( this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
if ((drawing != -1) && (fLightPB->GetInt(kShowConeBool, t) || (extDispFlags & EXT_DISP_ONLY_SELECTED)))
DrawCone(t, gw, fLightPB->GetFloat( kAttenMaxFalloffEdit, t ) );
}
else if( this->ClassID() == RTDIR_LIGHT_CLASSID )
{
if ((extDispFlags & EXT_DISP_ONLY_SELECTED))
DrawCone(t, gw, 500/*GetTDist(t)*/);
}
return gw->checkHitCode();
}
//// DrawArrow ///////////////////////////////////////////////////////////////
void plRTLightBase::DrawArrow( TimeValue t, GraphicsWindow *gw, Point3 &direction, float dist )
{
Point3 pts[ 5 ];
pts[ 0 ] = Point3( 0, 0, 0 );
pts[ 1 ] = direction * dist;
pts[ 3 ] = pts[ 1 ] - direction * 10.f;
pts[ 2 ] = pts[ 3 ] + Point3( direction.y, direction.z, direction.x ) * 5.f;
gw->polyline( 4, pts, nil, nil, true, nil );
}
int plRTLightBase::HitTest(TimeValue t, INode *node, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt)
{
DWORD savedLimits;
GraphicsWindow *gw = vpt->getGW();
HitRegion hitRegion;
int res;
Matrix3 m;
MakeHitRegion(hitRegion, type, crossing, 4, p);
Material *mtl = gw->getMaterial();
gw->setRndLimits( ((savedLimits = gw->getRndLimits()) | GW_PICK) & ~(GW_ILLUM|GW_BACKCULL));
GetMat(t,node,vpt,m);
//BuildMeshes(t);
gw->setTransform(m);
res = fMesh.select( gw, mtl, &hitRegion, flags & HIT_ABORTONHIT);
// if not, check the target line, and set the pair flag if it's hit
if( !res )
{
// this special case only works with point selection of targeted lights
if((type != HITTYPE_POINT) || !node->GetTarget())
return 0;
// don't let line be active if only looking at selected stuff and target isn't selected
if((flags & HIT_SELONLY) && !node->GetTarget()->Selected() )
return 0;
gw->clearHitCode();
if(res = DrawConeAndLine(t, node, gw, -1))
node->SetTargetNodePair(1);
}
gw->setRndLimits(savedLimits);
return res;
//return fMesh.select(gw,node->Mtls(),&hitRegion,flags & HIT_ABORTONHIT,node->NumMtls());
}
static void GenericSnap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt)
{
// Make sure the vertex priority is active and at least as important as the best snap so far
if(snap->vertPriority > 0 && snap->vertPriority <= snap->priority)
{
Matrix3 tm = inode->GetObjectTM(t);
GraphicsWindow *gw = vpt->getGW();
gw->setTransform(tm);
Point2 fp = Point2((float)p->x, (float)p->y);
IPoint3 screen3;
Point2 screen2;
Point3 vert(0.0f,0.0f,0.0f);
gw->wTransPoint(&vert,&screen3);
screen2.x = (float)screen3.x;
screen2.y = (float)screen3.y;
// Are we within the snap radius?
int len = (int)Length(screen2 - fp);
if(len <= snap->strength)
{
// Is this priority better than the best so far?
if(snap->vertPriority < snap->priority)
{
snap->priority = snap->vertPriority;
snap->bestWorld = vert * tm;
snap->bestScreen = screen2;
snap->bestDist = len;
}
// Closer than the best of this priority?
else if(len < snap->bestDist)
{
snap->priority = snap->vertPriority;
snap->bestWorld = vert * tm;
snap->bestScreen = screen2;
snap->bestDist = len;
}
}
}
}
void plRTLightBase::Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt)
{
GenericSnap(t,inode,snap,p,vpt);
}
// This generic snap routine is used to snap to the 0,0,0 point of the given node. For lights,
// this works to snap all types.
RefTargetHandle plRTLightBase::GetReference(int i)
{
/*
kRefProjMap,
kRefShadowProjMap,
kRefShadowType,
*///Texmap* MyMap;
switch(i)
{
case kRefGeneralLightProp:
return NULL;
case kRefProjMap:
//if(fLightPB->GetTexmap(kProjMapTexButton, 0) != NULL)
//{
// MyMap = fLightPB->GetTexmap(kProjMapTexButton, 0);
//return (RefTargetHandle) MyMap;
//}else
return NULL;
case kRefShadowProjMap:
return NULL;
case kRefShadowType:
return NULL;
case kRefOmniLight:
case kRefSpotLight:
case kRefTSpotLight:
case kRefDirLight:
case kRefTDirLight:
case kRefProjDirLight:
return (RefTargetHandle)fLightPB;
default:
return NULL;
}
}
void plRTLightBase::SetReference(int ref, RefTargetHandle rtarg)
{
//Texmap* MyMap;
switch(ref)
{
case kRefGeneralLightProp:
return;
case kRefProjMap:
//MyMap = (Texmap *)rtarg;
//fLightPB->SetValue(kProjMapTexButton, 0, MyMap);
//if (projMapName)
// projMapName->SetText(projMap?projMap->GetFullName().data():GetString(IDS_DB_NONE));
return;
case kRefShadowProjMap:
return;
case kRefShadowType:
return;
case kRefOmniLight:
case kRefSpotLight:
case kRefTSpotLight:
case kRefDirLight:
case kRefTDirLight:
case kRefProjDirLight:
fLightPB = (IParamBlock2*)rtarg; break;
}
//fLightPB = (IParamBlock2*)rtarg;
}
RefResult plRTLightBase::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message)
{
if( fLightPB )
{
ParamID param = fLightPB->LastNotifyParamID();
if( param == kAmbientOnlyStub )
{
fLightPB->EnableNotifications( false );
fLightPB->SetValue( kAmbientOnlyStub, TimeValue( 0 ), false );
// Assume this was true, since, well, we're IN NotifyRefChanged....
fLightPB->EnableNotifications( true );
return REF_SUCCEED;
}
}
return REF_SUCCEED;
}
void plRTLightBase::BeginEditParams(IObjParam *ip, ULONG flags, Animatable *prev)
{
fIP = ip;
fClassDesc->BeginEditParams(ip, this, flags, prev);
}
void plRTLightBase::EndEditParams(IObjParam *ip, ULONG flags, Animatable *next)
{
GenLight::EndEditParams( ip, flags, next );
fIP = NULL;
fClassDesc->EndEditParams(ip, this, flags, next);
}
RefResult plRTLightBase::EvalLightState(TimeValue t, Interval& valid, LightState *ls)
{
//t uselight;
//#if 0 //fLightPB->GetInt(kLightOn, t);
if(fLightPB->GetInt(kLightOn, t) == true)
ls->color = GetRGBColor(t,valid);
else
ls->color = Color(0,0,0);
ls->on = fLightPB->GetInt(kLightOn, t);
ls->intens = GetIntensity(t, valid);
if( this->ClassID() == RTSPOT_LIGHT_CLASSID || this->ClassID() == RTOMNI_LIGHT_CLASSID )
{
ls->hotsize = GetHotspot(t, valid);
ls->fallsize = GetFallsize(t, valid);
ls->useNearAtten = GetUseAttenNear();
ls->useAtten = GetUseAtten();
ls->attenStart = GetAtten(t, ATTEN_START, valid);
ls->attenEnd = GetAtten(t, ATTEN_END, valid);
}else
{
ls->hotsize = 20;
ls->fallsize = 10000;
ls->useNearAtten = false; //GetUseAttenNear();
ls->useAtten = false; //GetUseAtten();
//ls->attenStart = GetAtten(t, ATTEN_START, valid);
//ls->attenEnd = GetAtten(t, ATTEN_END, valid);
}
ls->shape = GW_SHAPE_CIRCULAR; //fLightPB->GetInt(kLightShapeRadio);
ls->aspect = -1.0;//GetAspect(t, valid);
ls->overshoot = false; //GetOvershoot();
ls->shadow = GetShadow();
ls->ambientOnly = false; //fLightPB->GetValue( kAmbiOnly,t, ls->ambientOnly, valid); //ls->ambientOnly = fLightP.AmbiOnly;
ls->affectDiffuse = true; //fLightPB->GetInt(kDiffOn,t); //ls->affectDiffusey = fLightP.AmbiOnly;
ls->affectSpecular = fLightPB->GetInt(kSpec,t); //ls- = fLightP.DiffOn;;
//ls->
if( this->ClassID() == RTOMNI_LIGHT_CLASSID )
ls->type = OMNI_LGT;
else if( this->ClassID() == RTDIR_LIGHT_CLASSID || this->ClassID() == RTPDIR_LIGHT_CLASSID )
ls->type = DIRECT_LGT;
else
ls->type = SPOT_LGT;
return REF_SUCCEED;
}
#if 0
#define PLASMAOBJ_DATA_CHUNK 1
IOResult plRTLightBase::Save(ISave* isave)
{
return IO_OK;
}
IOResult plRTLightBase::Load(ILoad* iload)
{
ULONG nb;
IOResult res;
int numrefs = 0;
while (IO_OK == (res = iload->OpenChunk()))
{
if (iload->CurChunkID() == PLASMAOBJ_DATA_CHUNK)
res = iload->Read(&numrefs, sizeof(int), &nb);
iload->CloseChunk();
if (res != IO_OK)
return res;
}
return IO_OK;
}
#endif
ObjLightDesc *plRTLightBase::CreateLightDesc(INode *n, BOOL forceShadowBuf)
{
return NULL;
}
void plRTLightBase::SetHotspot(TimeValue t, float f)
{
if(!IsSpot())
return;
if(f < 0.5f)
f = 0.5f;
if(!IsDir() && (f > 179.5f))
f = 179.5f;
//pblock->SetValue( PB_HOTSIZE, t, f );
fLightPB->SetValue(kHotSpot, t, f);
//fLightP.HotSpot = f;
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
float plRTLightBase::GetHotspot(TimeValue t, Interval& valid)
{
Interval iv;
if(!IsSpot() && !IsDir())
return -1.0f;
float f;
//pblock->GetValue( PB_HOTSIZE, t, f, valid );
if(IsSpot())
fLightPB->GetValue(kHotSpot, t, f, FOREVER);
else
f = 20.0;
if(GetFallsize(t, iv) < f )
return GetFallsize(t, iv) - 2.0;
return f;
}
void plRTLightBase::SetRGBColor(TimeValue t, Point3& rgb)
{
//fLightPB->SetValue(plRTLightBase::kRed, t, rgb.x);
//fLightPB->SetValue(plRTLightBase::kGreen, t, rgb.y);
//fLightPB->SetValue(plRTLightBase::kBlue, t, rgb.z);
fLightPB->SetValue(kLightColor, t, rgb );
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
Point3 plRTLightBase::GetRGBColor(TimeValue t, Interval &valid)
{
//Point3 Foo = Point3(fLightPB->GetInt(plRTLightBase::kRed, t), fLightPB->GetInt(plRTLightBase::kGreen, t), fLightPB->GetInt(plRTLightBase::kBlue, t));
Point3 rgb;
fLightPB->GetValue( kLightColor, t, rgb, valid );
return rgb;
}
void plRTLightBase::SetFallsize(TimeValue t, float f)
{
if(!IsSpot() )
return;
if(f < 0.5f)
f = 0.5f;
if(!IsDir() && (f > 179.5f))
f = 179.5f;
//pblock->SetValue( PB_FALLSIZE, t, f );
fLightPB->SetValue(kFallOff, t, f);
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
float plRTLightBase::GetFallsize(TimeValue t, Interval& valid)
{
if(!IsSpot() && !IsDir())
return -1.0f;
float f;
//pblock->GetValue( PB_FALLSIZE, t, f, valid );
if(IsSpot())
fLightPB->GetValue(kFallOff, t, f, valid);
else
f = 200.0;
return f;
}
void plRTLightBase::SetAtten(TimeValue t, int which, float f)
{
if(which != ATTEN_START)
fLightPB->SetValue(kAttenMaxFalloffEdit, t, f);
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
float plRTLightBase::GetAtten(TimeValue t, int which, Interval& valid)
{
float f = 0.0;
//if(fLightPB->GetInt(kEndAttenFar, t) == 1)
//if(LyteType == RT_OMNI)
// fLightPB->GetValue(kStartAttenFar, t, f, FOREVER);
//else
// fLightPB->GetValue(kStartAttenNear, t, f, FOREVER);
if(which == LIGHT_ATTEN_START)
return f;
else
return( fLightPB->GetFloat(kAttenMaxFalloffEdit, t));
//return f;
}
void plRTLightBase::SetTDist(TimeValue t, float f)
{
// int i;
// fLightPB->GetInt(kLightType, t, i);
//pblock->SetValue( PB_TDIST, t, f );
//To be implemented.
if( IHasAttenuation() )
fLightPB->SetValue(kAttenMaxFalloffEdit, t, f);
//fLightPB->SetValue(kTargetDist, t, f);
NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);
}
float plRTLightBase::GetTDist(TimeValue t, Interval& valid)
{
if(!IsSpot())
return -1.0f;
// int i;
//fLightPB->GetValue(kLightType, t, i, valid);
float f = -1.0;
fLightPB->GetFloat( kAttenMaxFalloffEdit, t );
//pblock->GetValue( PB_TDIST, t, f, valid );
//fLightPB->GetValue(kTargetDist, t, f, valid);
return f;
}
void plRTLightBase::SetConeDisplay(int s, int notify)
{
if(!IsDir())
fLightPB->SetValue(kShowConeBool, 0, s);
if(notify && IsSpot())
NotifyDependents(FOREVER, PART_OBJ, REFMSG_CHANGE);
}
BOOL plRTLightBase::GetConeDisplay(void)
{
if(!IsDir())
return fLightPB->GetInt(kShowConeBool);
return
false;
}
void plRTLightBase::SetProjMap(BitmapInfo* pmap)
{
//plLayerTex* MyMap = TRACKED_NEW plLayerTex;
if(!fTex)
fTex = TRACKED_NEW plLayerTex;
fTex->SetBitmap(pmap);
ReplaceReference(kRefProjMap,fTex);
IParamBlock2 *bitmapPB = fTex->GetParamBlockByID(plLayerTex::kBlkBitmap);
bitmapPB->SetValue(kBmpUseBitmap, 0, 1);
// This is set in the call to fTex->SetBitmap(pmap)
//PBBitmap pbb(*pmap);
//bitmapPB->SetValue(kBmpBitmap, 0, &pbb);
//Texmap* MyMap;
//fLightPB->GetValue(kProjMapTexButton, 0, MyMap, FOREVER);
if (fTex) fLightPB->SetValue(kUseProjectorBool, 0, true);
NotifyDependents(FOREVER,0,REFMSG_SUBANIM_STRUCTURE_CHANGED);
if( fLightPB->GetMap() )
{
fLightPB->GetMap()->Invalidate(kProjMapTexButton);
fLightPB->GetMap()->Invalidate(kUseProjectorBool);
}
}
BOOL plRTLightBase::GetShadow()
{
return fLightPB->GetInt(kCastShadows);
}
void plRTLightBase::SetShadow(int a)
{
fLightPB->SetValue(kCastShadows, 0, 1);
}
Texmap* plRTLightBase::GetProjMap()
{
if( !fLightPB->GetInt(kUseProjectorBool) )
return NULL;
if( GetTex() )
{
const char* dbgTexName = GetTex()->GetName();
IParamBlock2 *bitmapPB = fTex->GetParamBlockByID(plLayerTex::kBlkBitmap);
hsAssert(bitmapPB, "LayerTex with no param block");
int noCompress = fLightPB->GetInt(kProjNoCompress);
int noMip = fLightPB->GetInt(kProjNoMip);
bitmapPB->SetValue(kBmpNonCompressed, TimeValue(0), noCompress);
bitmapPB->SetValue(kBmpNoFilter, TimeValue(0), noMip);
}
return (Texmap*) GetTex();
}
void plRTLightBase::UpdateTargDistance(TimeValue t, INode* inode)
{
if( this->ClassID() == RTSPOT_LIGHT_CLASSID )
{
Point3 pt,v[3];
if (GetTargetPoint(t, inode, pt))
{
Matrix3 tm = inode->GetObjectTM(t);
float den = FLength(tm.GetRow(2));
float dist = (den!=0) ? FLength(tm.GetTrans()-pt) / den : 0.0f;
fLightPB->SetValue(kAttenMaxFalloffEdit, t, dist);
// fLightPB->SetValue(kTargetDist, t, dist);
//TCHAR buf[40];
//_stprintf(buf,_T("%0.3f"),targDist);
//SetWindowText(GetDlgItem(hSpotLight,IDC_TARG_DISTANCE),buf);
}
}
}
///
//
//
// Target Creation for Targeted Lights...
//
//
//
#if 0
class TSpotCreationManager : public MouseCallBack, ReferenceMaker
{
private:
CreateMouseCallBack *createCB;
INode *lgtNode,*targNode;
plRTLightBase *lgtObject;
TargetObject *targObject;
int attachedToNode;
IObjCreate *createInterface;
ClassDesc *cDesc;
Matrix3 mat; // the nodes TM relative to the CP
IPoint2 pt0;
int ignoreSelectionChange;
int lastPutCount;
void CreateNewObject();
int NumRefs() { return 1; }
RefTargetHandle GetReference(int i) { return (RefTargetHandle)lgtNode; }
void SetReference(int i, RefTargetHandle rtarg) { lgtNode = (INode *)rtarg; }
// StdNotifyRefChanged calls this, which can change the partID to new value
// If it doesnt depend on the particular message& partID, it should return
// REF_DONTCARE
RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget,
PartID& partID, RefMessage message);
public:
void Begin( IObjCreate *ioc, ClassDesc *desc );
void End();
TSpotCreationManager() { ignoreSelectionChange = FALSE; }
int proc( HWND hwnd, int msg, int point, int flag, IPoint2 m );
BOOL SupportAutoGrid(){return TRUE;}
};
#define CID_TSPOTCREATE CID_USER + 3
class TSpotCreateMode : public CommandMode {
TSpotCreationManager proc;
public:
void Begin( IObjCreate *ioc, ClassDesc *desc ) { proc.Begin( ioc, desc ); }
void End() { proc.End(); }
int Class() { return CREATE_COMMAND; }
int ID() { return CID_TSPOTCREATE; }
MouseCallBack *MouseProc(int *numPoints) { *numPoints = 1000000; return &proc; }
ChangeForegroundCallback *ChangeFGProc() { return CHANGE_FG_SELECTED; }
BOOL ChangeFG( CommandMode *oldMode ) { return (oldMode->ChangeFGProc() != CHANGE_FG_SELECTED); }
void EnterMode() {
}
void ExitMode() {
}
BOOL IsSticky() { return FALSE; }
};
static TSpotCreateMode theTSpotCreateMode;
#endif
#if 0
void TSpotCreationManager::Begin( IObjCreate *ioc, ClassDesc *desc )
{
createInterface = ioc;
cDesc = desc;
attachedToNode = FALSE;
createCB = NULL;
lgtNode = NULL;
targNode = NULL;
lgtObject = NULL;
targObject = NULL;
CreateNewObject();
}
void TSpotCreationManager::End()
{
if ( lgtObject ) {
lgtObject->EndEditParams( (IObjParam*)createInterface, END_EDIT_REMOVEUI, NULL);
if ( !attachedToNode ) {
// RB 4-9-96: Normally the hold isn't holding when this
// happens, but it can be in certain situations (like a track view paste)
// Things get confused if it ends up with undo...
theHold.Suspend();
//delete lgtObject;
lgtObject->DeleteThis(); // JBW 11.1.99, this allows scripted plugin lights to delete cleanly
lgtObject = NULL;
theHold.Resume();
// RB 7/28/97: If something has been put on the undo stack since this object was created, we have to flush the undo stack.
if (theHold.GetGlobalPutCount()!=lastPutCount) {
GetSystemSetting(SYSSET_CLEAR_UNDO);
}
macroRec->Cancel(); // JBW 4/23/99
}
else if ( lgtNode ) {
// Get rid of the reference.
DeleteReference(0); // sets lgtNode = NULL
}
}
}
RefResult TSpotCreationManager::NotifyRefChanged(
Interval changeInt,
RefTargetHandle hTarget,
PartID& partID,
RefMessage message)
{
switch (message) {
case REFMSG_PRENOTIFY_PASTE:
case REFMSG_TARGET_SELECTIONCHANGE:
if ( ignoreSelectionChange ) {
break;
}
if (lgtObject && lgtNode==hTarget) {
// this will set camNode== NULL;
DeleteReference(0);
goto endEdit;
}
// fall through
case REFMSG_TARGET_DELETED:
if ( lgtObject && lgtNode==hTarget ) {
endEdit:
lgtObject->EndEditParams( (IObjParam*)createInterface, 0, NULL);
lgtObject = NULL;
lgtNode = NULL;
CreateNewObject();
attachedToNode = FALSE;
}
else if (targNode==hTarget) {
targNode = NULL;
targObject = NULL;
}
break;
}
return REF_SUCCEED;
}
void TSpotCreationManager::CreateNewObject()
{
lgtObject = (plRTLightBase *)cDesc->Create();
lastPutCount = theHold.GetGlobalPutCount();
macroRec->BeginCreate(cDesc); // JBW 4/23/99
// Start the edit params process
if ( lgtObject ) {
lgtObject->BeginEditParams( (IObjParam*)createInterface, BEGIN_EDIT_CREATE, NULL );
}
}
static void whoa(){};
static BOOL needToss;
int TSpotCreationManager::proc(
HWND hwnd,
int msg,
int point,
int flag,
IPoint2 m )
{
int res;
TSTR targName;
ViewExp *vpx = createInterface->GetViewport(hwnd);
assert( vpx );
switch ( msg ) {
case MOUSE_POINT:
switch ( point ) {
case 0:
pt0 = m;
assert( lgtObject );
vpx->CommitImplicitGrid(m, flag); //KENNY MERGE
if ( createInterface->SetActiveViewport(hwnd) ) {
return FALSE;
}
if (createInterface->IsCPEdgeOnInView()) {
res = FALSE;
goto done;
}
// if lights were hidden by category, re-display them
GetCOREInterface()->SetHideByCategoryFlags(
GetCOREInterface()->GetHideByCategoryFlags() & ~HIDE_LIGHTS);
if ( attachedToNode ) {
// send this one on its way
lgtObject->EndEditParams( (IObjParam*)createInterface, 0, NULL);
macroRec->EmitScript(); // JBW 4/23/99
// Get rid of the reference.
if (lgtNode)
DeleteReference(0);
// new object
CreateNewObject(); // creates lgtObject
}
needToss = theHold.GetGlobalPutCount()!=lastPutCount;
theHold.Begin(); // begin hold for undo
mat.IdentityMatrix();
// link it up
lgtNode = createInterface->CreateObjectNode( lgtObject);
attachedToNode = TRUE;
assert( lgtNode );
createCB = lgtObject->GetCreateMouseCallBack();
createInterface->SelectNode( lgtNode );
// Create target object and node
targObject = TRACKED_NEW TargetObject;
assert(targObject);
targNode = createInterface->CreateObjectNode( targObject);
assert(targNode);
targName = lgtNode->GetName();
targName += GetString(IDS_DB_DOT_TARGET);
targNode->SetName(targName);
// hook up camera to target using lookat controller.
createInterface->BindToTarget(lgtNode,targNode);
// Reference the new node so we'll get notifications.
MakeRefByID( FOREVER, 0, lgtNode);
// Position camera and target at first point then drag.
mat.IdentityMatrix();
//mat[3] = vpx->GetPointOnCP(m);
#ifdef _3D_CREATE
mat.SetTrans( vpx->SnapPoint(m,m,NULL,SNAP_IN_3D) );
#else
mat.SetTrans(vpx->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
createInterface->SetNodeTMRelConstPlane(lgtNode, mat);
createInterface->SetNodeTMRelConstPlane(targNode, mat);
lgtObject->Enable(1);
ignoreSelectionChange = TRUE;
createInterface->SelectNode( targNode,0);
ignoreSelectionChange = FALSE;
res = TRUE;
break;
case 1:
if (Length(m-pt0)<2)
goto abort;
//mat[3] = vpx->GetPointOnCP(m);
#ifdef _3D_CREATE
mat.SetTrans( vpx->SnapPoint(m,m,NULL,SNAP_IN_3D) );
#else
mat.SetTrans(vpx->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
macroRec->Disable(); // JBW 4/23/99
createInterface->SetNodeTMRelConstPlane(targNode, mat);
macroRec->Enable();
ignoreSelectionChange = TRUE;
createInterface->SelectNode( lgtNode);
ignoreSelectionChange = FALSE;
theHold.Accept(IDS_DS_CREATE);
createInterface->AddLightToScene(lgtNode);
createInterface->RedrawViews(createInterface->GetTime());
res = FALSE; // We're done
break;
}
break;
case MOUSE_MOVE:
//mat[3] = vpx->GetPointOnCP(m);
#ifdef _3D_CREATE
mat.SetTrans( vpx->SnapPoint(m,m,NULL,SNAP_IN_3D) );
#else
mat.SetTrans(vpx->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
macroRec->Disable(); // JBW 4/23/99
createInterface->SetNodeTMRelConstPlane(targNode, mat);
macroRec->Enable();
createInterface->RedrawViews(createInterface->GetTime());
macroRec->SetProperty(lgtObject, _T("target"), // JBW 4/23/99
mr_create, Class_ID(TARGET_CLASS_ID, 0), GEOMOBJECT_CLASS_ID, 1, _T("transform"), mr_matrix3, &mat);
res = TRUE;
break;
case MOUSE_FREEMOVE:
SetCursor(LoadCursor(hInstance, MAKEINTRESOURCE(IDC_CROSS_HAIR)));
#ifdef _OSNAP
//Snap Preview
#ifdef _3D_CREATE
vpx->SnapPreview(m,m,NULL, SNAP_IN_3D);
#else
vpx->SnapPreview(m,m,NULL, SNAP_IN_PLANE);
#endif
#endif
vpx->TrackImplicitGrid(m); //KENNY MERGE
break;
case MOUSE_PROPCLICK:
// right click while between creations
createInterface->RemoveMode(NULL);
break;
case MOUSE_ABORT:
abort:
assert( lgtObject );
lgtObject->EndEditParams( (IObjParam*)createInterface,0,NULL);
// Toss the undo stack if param changes have been made
macroRec->Cancel(); // JBW 4/23/99
theHold.Cancel(); // deletes both the camera and target.
if (needToss)
GetSystemSetting(SYSSET_CLEAR_UNDO);
lgtNode = NULL;
targNode = NULL;
createInterface->RedrawViews(createInterface->GetTime());
CreateNewObject();
attachedToNode = FALSE;
res = FALSE;
}
done:
//KENNY MERGE
if ((res == CREATE_STOP)||(res==CREATE_ABORT))
vpx->ReleaseImplicitGrid();
createInterface->ReleaseViewport(vpx);
return res;
}
#endif