int SphereObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
float r;
Point3 p1,center;
if (msg == MOUSE_FREEMOVE)
{
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE)
{
switch(point)
{
case 0: // only happens with MOUSE_POINT msg
// Find the node and plug in the wire color
{
ULONG handle;
ob->NotifyDependents(FOREVER, (PartID)&handle, REFMSG_GET_NODE_HANDLE);
INode *node = GetCOREInterface()->GetINodeByHandle(handle);
if (node) node->SetWireColor(RGB(255, 0, 0));
}
ob->pblock2->SetValue(PB_RADIUS,0,0.0f);
ob->suspendSnap = TRUE;
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D);
mat.SetTrans(p0);
break;
case 1:
mat.IdentityMatrix();
//mat.PreRotateZ(HALFPI);
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D);
r = Length(p1-p0) / 7.0f;
mat.SetTrans(p0);
ob->pblock2->SetValue(PB_RADIUS,0,r);
ob->pmapParam->Invalidate();
if (flags&MOUSE_CTRL)
{
float ang = (float)atan2(p1.y-p0.y,p1.x-p0.x);
mat.PreRotateZ(ob->ip->SnapAngle(ang));
}
if (msg==MOUSE_POINT)
{
ob->suspendSnap = FALSE;
return (Length(m-sp0)<3 || Length(p1-p0)<0.1f)?CREATE_ABORT:CREATE_STOP;
}
break;
}
}
else
if (msg == MOUSE_ABORT)
{
return CREATE_ABORT;
}
return TRUE;
}
int ProtHelpObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0:
ph->suspendSnap = TRUE;
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) {
ph->suspendSnap = FALSE;
return 0;
}
break;
}
} else if (msg == MOUSE_ABORT) {
return CREATE_ABORT;
}
return 1;
}
int MorphObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
Point3 pt;
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
pt = vpt->GetPointOnCP(m);
mat.SetTrans(pt);
break;
case 1:
pt = vpt->GetPointOnCP(m);
mat.SetTrans(pt);
if (msg==MOUSE_POINT)
return CREATE_STOP;
break;
}
}
else
if (msg == MOUSE_ABORT)
return CREATE_ABORT;
return TRUE;
}
int TessendorfOceanCreateCallBack::proc(ViewExp *vpt,int msg, int point, int /*flags*/, IPoint2 m, Matrix3& mat )
{
//TODO: Implement the mouse creation code here
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
if (msg == MOUSE_POINT || msg == MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
ob->suspendSnap = TRUE;
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
//Set a default overall size in the parameter block
ob->pblock2->SetValue(pb_width, ob->ip->GetTime(), 0.0f);
ob->pblock2->SetValue(pb_length, ob->ip->GetTime(), 0.0f);
break;
case 1:
{
ob->suspendSnap = TRUE;
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
Point3 diff = p1 - p0;
mat.SetTrans(p0 + diff / 2.0f);
//Set the overall size in parameter block
ob->pblock2->SetValue(pb_width, ob->ip->GetTime(), abs(diff.x));
ob->pblock2->SetValue(pb_length, ob->ip->GetTime(), abs(diff.y));
//Invalidate and display the mesh in the viewport
tessendorfocean_param_blk.InvalidateUI();
break;
}
case 2: // happens when user releases mouse
{
ob->suspendSnap = TRUE;
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
Point3 diff = p1 - p0;
if (abs(diff.x) < MIN_WIDTH || abs(diff.y) < MIN_LENGTH)
{
return CREATE_ABORT; // abort if the size is too small
}
else
{
return CREATE_STOP;
}
}
}
} else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
int WindObjCreateCallback::proc(
ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat)
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE)
{
#ifdef _3D_CREATE
DWORD snapdim = SNAP_IN_3D;
#else
DWORD snapdim = SNAP_IN_PLANE;
#endif
switch(point)
{
case 0:
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,snapdim);
mat.SetTrans(p0);
break;
case 1:
if (ob->ClassID()==Class_ID(GRAVITYOBJECT_CLASS_ID,0))
{
mat.IdentityMatrix();
mat.RotateX(PI);
mat.SetTrans(p0);
}
p1 = vpt->GetPointOnCP(m);
ob->pblock2->SetValue(PB_DISPLENGTH,0,Length(p1-p0)/2.0f);
// ob->pmapParam->Invalidate();
wind_param_blk.InvalidateUI();
if (msg==MOUSE_POINT)
{
if (Length(m-sp0)<3) return CREATE_ABORT;
else return CREATE_STOP;
}
break;
}
}
else
{
if (msg == MOUSE_ABORT)
{
return CREATE_ABORT;
}
else
if (msg == MOUSE_FREEMOVE)
{
vpt->SnapPreview(m,m);
}
}
return TRUE;
}
//---------------------------------------------------------------------------
//
int LuminaireObjectCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
#ifdef _OSNAP
if (msg == MOUSE_FREEMOVE)
{
#ifdef _3D_CREATE
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
#else
vpt->SnapPreview(m,m,NULL, SNAP_IN_PLANE);
#endif
}
#endif // _OSNAP
if (msg == MOUSE_POINT || msg == MOUSE_MOVE)
{
switch(point)
{
case 0:
{
mpObject->dumFlags |= CREATING; // tell object we're building it so we can disable snapping to itself
#ifdef _3D_CREATE
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_3D));
#else
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
break;
}
case 1:
#ifdef _3D_CREATE
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_3D));
#else
mat.SetTrans(vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE));
#endif
if (msg == MOUSE_POINT)
{
mpObject->dumFlags &= ~CREATING;
return 0;
}
break;
}
}
else if (msg == MOUSE_ABORT)
{
mpObject->dumFlags &= ~CREATING;
return CREATE_ABORT;
}
return TRUE;
}
int TriPatchCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
Point3 d;
#ifdef _OSNAP
if (msg == MOUSE_FREEMOVE)
{
#ifdef _3D_CREATE
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
#else
vpt->SnapPreview(m,m,NULL, SNAP_IN_PLANE);
#endif
}
#endif
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0:
sp0 = m;
ob->creating = 1; // tell object we're building it so we can disable snapping to itself
#ifdef _3D_CREATE
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D);
#else
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
#endif
ob->pblock->SetValue(PB_WIDTH,0,0.0f);
ob->pblock->SetValue(PB_LENGTH,0,0.0f);
p1 = p0 + Point3(0.01f,0.01f,0.0f);
mat.SetTrans(float(.5)*(p0+p1));
break;
case 1:
#ifdef _3D_CREATE
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D);
#else
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
#endif
mat.SetTrans(float(.5)*(p0+p1));
d = p1-p0;
ob->pblock->SetValue(PB_WIDTH,0,float(fabs(d.x)));
ob->pblock->SetValue(PB_LENGTH,0,float(fabs(d.y)));
ob->pmapParam->Invalidate();
if (msg==MOUSE_POINT) {
ob->creating = 0;
return (Length(m-sp0)<3) ? CREATE_ABORT: CREATE_STOP;
}
break;
}
}
else
if (msg == MOUSE_ABORT) {
ob->creating = 0;
return CREATE_ABORT;
}
return TRUE;
}
int CreateSWrapObjectProc::createmethod(
ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat)
{ Point3 d;
#ifdef _3D_CREATE
DWORD snapdim = SNAP_IN_3D;
#else
DWORD snapdim = SNAP_IN_PLANE;
#endif
#ifdef _OSNAP
if (msg == MOUSE_FREEMOVE)
{ vpt->SnapPreview(m,m,NULL, snapdim);
}
#endif
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0:
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,snapdim);
mat.SetTrans(p0);
SWrapObj->pblock->SetValue(PB_ICONSIZE,0,0.01f);
SWrapObj->pmapParam->Invalidate();
break;
case 1: {
mat.IdentityMatrix();
sp1 = m;
p1 = vpt->SnapPoint(m,m,NULL,snapdim);
Point3 center = (p0+p1)/float(2);
mat.SetTrans(center);
SWrapObj->pblock->SetValue(PB_ICONSIZE,0,Length(p1-p0));
SWrapObj->pmapParam->Invalidate();
if (msg==MOUSE_POINT) {
if (Length(m-sp0)<3) {
return CREATE_ABORT;
} else {
ICustButton *iBut = GetICustButton(GetDlgItem(SWrapObj->hParams,IDC_AP_WRAPBUTTON));
iBut->Enable();
ReleaseICustButton(iBut);
return CREATE_STOP;
}
}
break;
}
}
} else {
if (msg == MOUSE_ABORT)
return CREATE_ABORT;
}
return TRUE;
}
int GSphereObjCreateCallBack::proc(ViewExp *vpt, int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Doing proc() on invalid viewport!"));
return FALSE;
}
Point3 p1, center;
if (msg == MOUSE_FREEMOVE)
{
vpt->SnapPreview(m, m, NULL, SNAP_IN_3D);
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
ob->suspendSnap = TRUE;
sp0 = m;
p0 = vpt->SnapPoint(m, m, NULL, SNAP_IN_3D);
mat.SetTrans(p0);
break;
case 1:
mat.IdentityMatrix();
p1 = vpt->SnapPoint(m, m, NULL, SNAP_IN_3D);
center = (p0+p1)/float(2);
mat.SetTrans(center);
mat.SetTrans(center);
container_param_blk.InvalidateUI();
if (flags&MOUSE_CTRL) {
float ang = (float)atan2(p1.y-p0.y, p1.x-p0.x);
mat.PreRotateZ(ob->ip->SnapAngle(ang));
}
if (msg==MOUSE_POINT) {
ob->suspendSnap = FALSE;
return (Length(m-sp0)<3)?CREATE_ABORT:CREATE_STOP;
}
break;
}
} else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
int
FogCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags,
IPoint2 m, Matrix3& mat)
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here?
DbgAssert(!"Doing proc() on invalid view port!");
return FALSE;
}
Point3 p1,center;
switch ( msg ) {
case MOUSE_POINT:
case MOUSE_MOVE:
switch ( point ) {
case 0: // only happens with MOUSE_POINT msg
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
break;
case 1:
mat.IdentityMatrix();
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
float radius = Length(p1-p0);
fogObject->pblock->SetValue(PB_FOG_SIZE,
fogObject->
iObjParams->GetTime(), radius);
fogObject->pmapParam->Invalidate();
if (flags&MOUSE_CTRL) {
float ang = (float)atan2(p1.y-p0.y,p1.x-p0.x);
mat.PreRotateZ(fogObject->iObjParams->SnapAngle(ang));
}
if (msg==MOUSE_POINT) {
return (Length(m-sp0)<3)?CREATE_ABORT:CREATE_STOP;
}
break;
}
break;
case MOUSE_ABORT:
return CREATE_ABORT;
}
return TRUE;
}
int
Cal3DCreateCallBack::proc(ViewExp *vpt, int msg, int point, int flags, IPoint2 m, Matrix3 &mat)
{
Point3 p1, center;
switch (msg)
{
case MOUSE_POINT:
case MOUSE_MOVE:
switch (point)
{
case 0: // only happens with MOUSE_POINT msg
sp0 = m;
p0 = vpt->SnapPoint(m, m, NULL, SNAP_IN_PLANE);
mat.SetTrans(p0);
if (msg == MOUSE_POINT)
{
return CREATE_STOP;
}
break;
}
break;
case MOUSE_ABORT:
return CREATE_ABORT;
}
return TRUE;
}
int TargetObjectCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
Point3 c;
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0:
c = vpt->GetPointOnCP(m);
mat.SetTrans(c);
return CREATE_STOP;
break;
}
}
else
if (msg == MOUSE_ABORT)
return CREATE_ABORT;
return TRUE;
}
// CAL-05/24/02: TODO: this should really go to core\decomp.cpp, and it should be optimized.
// For now, it's defined locally in individual files in the ctrl project.
static void comp_affine( const AffineParts &ap, Matrix3 &mat )
{
Matrix3 tm;
mat.IdentityMatrix();
mat.SetTrans( ap.t );
if ( ap.f != 1.0f ) { // has f component
tm.SetScale( Point3( ap.f, ap.f, ap.f ) );
mat = tm * mat;
}
if ( !ap.q.IsIdentity() ) { // has q rotation component
ap.q.MakeMatrix( tm );
mat = tm * mat;
}
if ( ap.k.x != 1.0f || ap.k.y != 1.0f || ap.k.z != 1.0f ) { // has k scale component
tm.SetScale( ap.k );
if ( !ap.u.IsIdentity() ) { // has u rotation component
Matrix3 utm;
ap.u.MakeMatrix( utm );
mat = Inverse( utm ) * tm * utm * mat;
} else {
mat = tm * mat;
}
}
}
int BlobMeshCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
//TODO: Implement the mouse creation code here
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
ob->suspendSnap = TRUE;
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
return CREATE_STOP;
break;
//TODO: Add for the rest of points
}
} else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
int
SwitchCreateCallBack::proc(ViewExp *vpt, int msg, int point, int flags,
IPoint2 m, Matrix3 &mat)
{
Point3 p1, center;
switch (msg)
{
case MOUSE_POINT:
case MOUSE_MOVE:
switch (point)
{
case 0: // only happens with MOUSE_POINT msg
sp0 = m;
p0 = vpt->SnapPoint(m, m, NULL, SNAP_IN_PLANE);
mat.SetTrans(p0);
break;
case 1:
mat.IdentityMatrix();
p1 = vpt->SnapPoint(m, m, NULL, SNAP_IN_PLANE);
mat.SetTrans(p0);
float radius = Length(p1 - p0);
switchSensorObject->pblock->SetValue(PB_S_SIZE,
switchSensorObject->iObjParams->GetTime(), radius);
switchSensorObject->pmapParam->Invalidate();
if (flags & MOUSE_CTRL)
{
float ang = (float)atan2(p1.y - p0.y, p1.x - p0.x);
mat.PreRotateZ(switchSensorObject->iObjParams->SnapAngle(ang));
}
if (msg == MOUSE_POINT)
{
return (Length(m - sp0) < 3) ? CREATE_ABORT : CREATE_STOP;
}
break;
}
break;
case MOUSE_ABORT:
return CREATE_ABORT;
}
return TRUE;
}
Matrix3 Jiggle::GetCurrentTM(TimeValue t)
{
INode* baseNode = NULL;
baseNode = selfNode;
Matrix3 selfTM;
Point3 pos = Point3(0.0f,0.0f,0.0f);
Interval for_ever = FOREVER;
posCtrl->GetValue(t, pos, for_ever, CTRL_ABSOLUTE);
if (baseNode != NULL )
{
selfTM = baseNode->GetNodeTM(t);
selfTM.SetTrans(selfTM * pos);
}
else
{
selfTM.IdentityMatrix();
selfTM.SetTrans(pos);
}
return selfTM;
}
void VRayCamera::getTM(TimeValue t, INode *node, ViewExp *vpt, Matrix3 &tm) {
tm=node->GetObjectTM(t);
AffineParts ap;
decomp_affine(tm, &ap);
tm.IdentityMatrix();
tm.SetRotate(ap.q);
tm.SetTrans(ap.t);
float scaleFactor=vpt->NonScalingObjectSize()*vpt->GetVPWorldWidth(tm.GetTrans())/360.0f;
tm.Scale(Point3(scaleFactor,scaleFactor,scaleFactor));
}
int ConeAngleManipCreateCallBack::proc(ViewExp *pVpt, int msg, int point, int flags,
IPoint2 m, Matrix3& mat ) {
float r;
Point3 p1, center;
if (msg == MOUSE_FREEMOVE)
{
pVpt->SnapPreview(m, m, NULL, SNAP_IN_3D);
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
// ob->suspendSnap = TRUE;
sp0 = m;
p0 = pVpt->SnapPoint(m, m, NULL, SNAP_IN_3D);
mat.SetTrans(p0);
break;
case 1:
mat.IdentityMatrix();
p1 = pVpt->SnapPoint(m, m, NULL, SNAP_IN_3D);
r = Length(p1-p0);
mat.SetTrans(p0);
mpManip->GetPBlock()->SetValue(kConeAngleDistance, 0, r);
ConeAngleManipBlock.InvalidateUI();
if (msg==MOUSE_POINT) {
return (Length(m-sp0)<3)?CREATE_ABORT:CREATE_STOP;
}
break;
}
} else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
BOOL plDistributor::ISetupNormals(plMaxNode* node, Mesh* mesh, BOOL radiateNorm) const
{
const char* dbgNodeName = node->GetName();
UVVert *normMap = mesh->mapVerts(kNormMapChan);
int numNormVerts = mesh->getNumMapVerts(kNormMapChan);
if( !mesh->mapSupport(kNormMapChan) || !mesh->mapVerts(kNormMapChan) || !mesh->mapFaces(kNormMapChan) )
{
mesh->setMapSupport(kNormMapChan);
mesh->setNumMapVerts(kNormMapChan, mesh->getNumVerts());
mesh->setNumMapFaces(kNormMapChan, mesh->getNumFaces());
}
int i;
if( radiateNorm )
{
Matrix3 otm = node->GetOTM();
Matrix3 invOtm = Inverse(otm);
invOtm.SetTrans(Point3(0,0,0));
invOtm.ValidateFlags();
for( i = 0; i < mesh->getNumVerts(); i++ )
{
Point3 pos = mesh->getVert(i) * otm;
pos = pos * invOtm;
mesh->setMapVert(kNormMapChan, i, pos);
}
}
else
{
mesh->checkNormals(true);
for( i = 0; i < mesh->getNumVerts(); i++ )
{
Point3 norm = mesh->getNormal(i);
mesh->setMapVert(kNormMapChan, i, norm);
}
}
TVFace* mapFaces = mesh->mapFaces(kNormMapChan);
Face* faces = mesh->faces;
for( i = 0; i < mesh->getNumFaces(); i++ )
{
mapFaces[i].setTVerts(faces[i].getVert(0), faces[i].getVert(1), faces[i].getVert(2));
}
return true;
}
int
APITestUtil::MakeTestXFormSurface(NURBSSet &nset, int p)
{
NURBSXFormSurface *s = new NURBSXFormSurface();
s->SetName(GetString(IDS_XFORM_SURFACE));
s->SetNSet(&nset);
s->SetParent(p);
Matrix3 mat;
mat.IdentityMatrix();
mat.SetTrans(Point3(-150, 150, 0));
s->SetXForm(0, mat);
return nset.AppendObject(s);
}
int ForceObjCreateCallback::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat)
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
#ifdef _3D_CREATE
DWORD snapdim = SNAP_IN_3D;
#else
DWORD snapdim = SNAP_IN_PLANE;
#endif
#ifdef _OSNAP
if (msg == MOUSE_FREEMOVE)
{ vpt->SnapPreview(m,m,NULL, snapdim);
}
#endif
if (msg==MOUSE_POINT||msg==MOUSE_MOVE)
{ switch(point)
{
case 0:
// if hidden by category, re-display particles and objects
GetCOREInterface()->SetHideByCategoryFlags(GetCOREInterface()->GetHideByCategoryFlags() & ~(HIDE_OBJECTS|HIDE_PARTICLES));
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,snapdim);
mat.SetTrans(p0);
break;
case 1:
p1 = vpt->SnapPoint(m,m,NULL,snapdim);
float x=Length(p1-p0);
ob->pblock->SetValue(PB_ICONSIZE,0,x);
ob->pmapParam->Invalidate();
if (msg==MOUSE_POINT)
{ if (Length(m-sp0)<3) return CREATE_ABORT;
else return CREATE_STOP;
}
break;
}
}
else
{ if (msg == MOUSE_ABORT)
return CREATE_ABORT;
}
return TRUE;
}
int TapeHelpObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
ob->enable = 1;
#ifdef _OSNAP
if (msg == MOUSE_FREEMOVE)
{
#ifdef _3D_CREATE
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
#else
vpt->SnapPreview(m,m,NULL, SNAP_IN_PLANE);
#endif
}
#endif
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
#ifdef _3D_CREATE
mat.SetTrans( vpt->SnapPoint(m,m,NULL,SNAP_IN_3D) );
#else
mat.SetTrans( vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE) );
#endif
if (point==1 && msg==MOUSE_POINT)
return 0;
}
else if (msg == MOUSE_ABORT)
return CREATE_ABORT;
return TRUE;
}
int
MaterialHandleCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point)
{
case 0: // only happens with MOUSE_POINT msg
ob->suspendSnap = TRUE;
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
//Set a default overall size in the parameter block
ob->pblock2->SetValue(materialHandle_size, ob->ip->GetTime(), 0.0f);
break;
case 1:
{
ob->suspendSnap = TRUE;
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
float speedFactor = 24.0f;
float theSize = (Length(p1 - p0) / speedFactor);
//Set the overall size in parameter block
ob->pblock2->SetValue(materialHandle_size, ob->ip->GetTime(), theSize);
//Invalidate and display the mesh in the viewport
materialHandle_param_blk.InvalidateUI();
break;
}
case 2:
{
return CREATE_STOP;
}
}
}
else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
static void UnwrapMatrixFromNormal(Point3& normal, Matrix3& mat)
{
Point3 vx;
vx.z = .0f;
vx.x = -normal.y;
vx.y = normal.x;
if ( vx.x == .0f && vx.y == .0f ) {
vx.x = 1.0f;
}
mat.SetRow(0,vx);
mat.SetRow(1,normal^vx);
mat.SetRow(2,normal);
mat.SetTrans(Point3(0,0,0));
mat.NoScale();
}
int CompassRoseObjCreateCallBack::proc( ViewExp *vpt,
int msg,
int point,
int flags,
IPoint2 m,
Matrix3& mat )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here
DbgAssert(!_T("Invalid viewport!"));
return FALSE;
}
if (msg == MOUSE_POINT)
{
if (point == 0)
{
ob->suspendSnap = TRUE;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
}
else
{
ob->suspendSnap = FALSE;
return 0;
}
}
else if (msg==MOUSE_MOVE)
{
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
ob->axisLength = max(AXIS_LENGTH, Length(p1-p0));
PostMessage(ob->hParams, RU_UPDATE, 0, 0);
}
else if (msg == MOUSE_ABORT)
{
return CREATE_ABORT;
}
else if (msg == MOUSE_FREEMOVE)
{
vpt->SnapPreview(m,m,NULL,SNAP_IN_PLANE);
}
return 1;
}
int HoudiniEngineMeshCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat )
{
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
ob->SetSuspendSnap(TRUE);
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(p0);
return CREATE_STOP;
break;
}
} else {
if (msg == MOUSE_ABORT) return CREATE_ABORT;
}
return TRUE;
}
int ListObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
Point3 d;
if (msg == MOUSE_FREEMOVE)
{
vpt->SnapPreview(m,m,NULL, SNAP_IN_3D);
}
else if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0:
// Find the node and plug in the wire color
{
ULONG handle;
ob->NotifyDependents(FOREVER, (PartID)&handle, REFMSG_GET_NODE_HANDLE);
INode *node = GetCOREInterface()->GetINodeByHandle(handle);
if (node) node->SetWireColor(RGB(255, 0, 0));
}
sp0 = m;
ob->suspendSnap = TRUE;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_3D);
p1 = p0 + Point3(.01,.01,.01);
mat.SetTrans(float(.5)*(p0+p1));
ob->pmapParam->Invalidate();
if (msg==MOUSE_POINT)
{
ob->suspendSnap = FALSE;
return CREATE_STOP;
}
break;
}
}
else
if (msg == MOUSE_ABORT) {
return CREATE_ABORT;
}
return TRUE;
}
void
ConeDistanceManipulator::Transform(TimeValue t, Point3& p, ViewExp* pVpt)
{
Ray viewRay; // The viewing vector in local coords
IPoint2 screenPt = GetMousePos();
pVpt->MapScreenToWorldRay((float)screenPt.x, (float)screenPt.y, viewRay);
Matrix3 tm;
tm = mpINode->GetObjectTM(t);
// Transform view ray to local coords
tm = Inverse(tm);
viewRay.p = viewRay.p * tm;
tm.SetTrans(Point3(0,0,0));
viewRay.dir = viewRay.dir * tm;
Point3 orthogViewDir = viewRay.dir;
orthogViewDir.z = 0.0;
// Plane& projPlane = Plane::msXZPlane.MostOrthogonal(viewRay, Plane::msYZPlane);
Plane projPlane(orthogViewDir, mDistance * mDirection);
Point3 newP;
bool b = projPlane.Intersect(viewRay, newP);
if (!b)
return;
float newDist = -newP.z;
SetDistance(newDist);
// Add a "handle"
Point3 center(0.0f, 0.0f, -newDist);
Plane conePlane(mDirection, center);
bool res = conePlane.Intersect(viewRay, newP);
if (!res)
return;
AddHandle(center, newP, pVpt);
}
int SinWaveObjCreateCallBack::proc(ViewExp *vpt,int msg, int point, int flags, IPoint2 m, Matrix3& mat ) {
float w;
if (msg==MOUSE_POINT||msg==MOUSE_MOVE) {
switch(point) {
case 0: // only happens with MOUSE_POINT msg
sp0 = m;
p0 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE); //vpt->GetPointOnCP(m);
mat.SetTrans(p0);
break;
case 1:
sp1 = m;
p1 = vpt->SnapPoint(m,m,NULL,SNAP_IN_PLANE); //vpt->GetPointOnCP(m);
w = float(4)*Length(p0-p1)/ob->Circles();
ob->pblock->SetValue(PB_WAVELEN,0,w);
ob->pmapParam->Invalidate();
break;
case 2:
if ( Length(sp1-sp0)<3 ) return CREATE_ABORT;
w = vpt->GetCPDisp(p1,Point3(0,0,1),sp1,m);
ob->pblock->SetValue(PB_AMPLITUDE,0,w);
ob->pblock->SetValue(PB_AMPLITUDE2,0,w);
ob->pmapParam->Invalidate();
if (msg==MOUSE_POINT)
return CREATE_STOP;
break;
}
}
else
if (msg == MOUSE_ABORT)
return CREATE_ABORT;
else
if (msg == MOUSE_FREEMOVE) {
vpt->SnapPreview(m,m);
}
return TRUE;
}
Matrix3 CActionExporter::get_bone_tm(CSkeletonExporter* pSkeleton,int boneIndex,unsigned int iMaxTime)
{
sMaxBoneNode_t bone = pSkeleton->m_MaxBones[boneIndex];
Matrix3 boneInitMTInv;
if(G_MaxEnv().m_bUseBeforeSkeletonPose)
boneInitMTInv = bone.m_SkinInitMT;
else
boneInitMTInv = bone.m_InitNodeTM0;
boneInitMTInv.Invert();
INode* pNode = bone.m_pNode;
Matrix3 BoneTM = boneInitMTInv * pNode->GetNodeTM(iMaxTime); //>GetNodeTM(iMaxTime);
Point3 Trans = BoneTM.GetTrans();
BoneTM.NoTrans();
//对骨骼进行缩放
Trans.x *= pSkeleton->m_fScale;
Trans.y *= pSkeleton->m_fScale;
Trans.z *= pSkeleton->m_fScale;
BoneTM.SetTrans(Trans);
return BoneTM;
}
