int AddNodalLink(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
CKAttributeManager* attman = ctx->GetAttributeManager();
beh->ActivateInput(0,FALSE);
beh->ActivateOutput(0);
CKGroup* group = (CKGroup*)beh->GetInputParameterObject(0);
CKParameterOut* param = group->GetAttributeParameter(attman->GetAttributeTypeByName(Network3dName));
if(!param) throw "Given Group isn't a Network";
N3DGraph* graph;
param->GetValue(&graph);
CK3dEntity* s = (CK3dEntity*)beh->GetInputParameterObject(1);
CK3dEntity* e = (CK3dEntity*)beh->GetInputParameterObject(2);
float b;
beh->GetInputParameterValue(3,&b);
graph->InsertEdge(s,e,b);
beh->ActivateOutput(0);
return CKBR_OK;
}
//************************************
// Method: PCIgnorePair
// FullName: PCIgnorePair
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PCIgnorePair(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
if( beh->IsInputActive(0) )
{
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
if( !target ) return CKBR_OWNERERROR;
CK3dEntity *targetA = (CK3dEntity *) beh->GetInputParameterObject(0);
CK3dEntity *targetB = (CK3dEntity *) beh->GetInputParameterObject(1);
int ignore = GetInputParameterValue<int>(beh,2);
//////////////////////////////////////////////////////////////////////////
// the world :
pWorld *world=GetPMan()->getWorld(target);
if(world){
world->cIgnorePair(targetA,targetB,ignore);
}
beh->ActivateInput(0,FALSE);
beh->ActivateOutput(0);
}
return 0;
}
//************************************
// Method: JDestroy
// FullName: JDestroy
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int JDestroy(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
if( beh->IsInputActive(0) )
{
beh->ActivateInput(0,FALSE);
//////////////////////////////////////////////////////////////////////////
//the object A:
int jointType = GetInputParameterValue<int>(beh,1);
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
CK3dEntity *targetB = (CK3dEntity *) beh->GetInputParameterObject(0);
if (!pFactory::Instance()->jointCheckPreRequisites(target,targetB,jointType))
{
return CK_OK;
}
// the world :
pWorld *worldA=GetPMan()->getWorldByBody(target);
pWorld *worldB=GetPMan()->getWorldByBody(targetB);
if (!worldA)
{
worldA = worldB;
}
if (!worldA)
{
beh->ActivateOutput(0);
return 0;
}
// the physic object A :
pRigidBody*bodyA= worldA->getBody(target);
pRigidBody*bodyB= worldA->getBody(targetB);
if(bodyA || bodyB)
{
pJoint *joint = worldA->getJoint(target,targetB,(JType)jointType);
if (joint)
{
worldA->deleteJoint(joint);
}
}
beh->ActivateOutput(0);
}
return 0;
}
int TextureSinus(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
// we get the amount value
float xamp=0.1f;
beh->GetInputParameterValue(0, &xamp);
// we get the amount value
float yamp=0.1f;
beh->GetInputParameterValue(1, &yamp);
float l= 1.0f;
beh->GetInputParameterValue(2, &l);
// we get the saved uv's
VxUV* savedUV = (VxUV*) beh->GetLocalParameterReadDataPtr(0);
// we get the interpolated mesh
CKMesh *mesh = (CKMesh*) beh->GetInputParameterObject(4);
int channel = -1;
beh->GetInputParameterValue(3, &channel);
int channelcount = mesh->GetChannelCount();
if (channel < -1 || channel >= channelcount) {
beh->ActivateInput(0, FALSE);
beh->ActivateOutput(0);
return CKBR_PARAMETERERROR;
}
CKDWORD Stride;
VxUV *uvarray = (VxUV*) mesh->GetModifierUVs(&Stride,channel);
int pointsNumber = mesh->GetModifierUVCount(channel);
float time;
beh->GetLocalParameterValue(1, &time);
float t;
for( int i=0 ; i<pointsNumber ; i++, uvarray =(VxUV *)((BYTE *)uvarray + Stride)) {
t = ((float)i/pointsNumber-0.5f)*4.0f+time*l;
uvarray->u = savedUV[i].u + ( 0.5f - savedUV[i].u ) * xamp * cosf(t);
uvarray->v = savedUV[i].v + ( 0.5f - savedUV[i].v ) * yamp * sinf(t);
}
mesh->ModifierUVMove(channel);
float pi = 3.1415926535f;
time += behcontext.DeltaTime * 0.001f;
if(l*time > 2*pi)
time -= (2*pi / l);
beh->SetLocalParameterValue(1, &time);
beh->ActivateInput(0, FALSE);
beh->ActivateOutput(0);
return CKBR_OK;
}
//************************************
// Method: PClothDetachFromShape
// FullName: PClothDetachFromShape
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PClothDetachFromShape(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
if( beh->IsInputActive(0) )
{
beh->ActivateInput(0,FALSE);
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
if( !target ) return CKBR_OWNERERROR;
//////////////////////////////////////////////////////////////////////////
CK3dEntity*shapeReference = (CK3dEntity *) beh->GetInputParameterObject(bbI_ShapeReference);
if (!shapeReference)
{
beh->ActivateOutput(0);
return CKBR_PARAMETERERROR;
}
pCloth *cloth = GetPMan()->getCloth(target->GetID());
if (!cloth)
{
beh->ActivateOutput(0);
return CKBR_PARAMETERERROR;
}
NxShape *shape = cloth->getWorld()->getShapeByEntityID(shapeReference->GetID());
if(shape)
{
cloth->detachFromShape((CKBeObject*)shapeReference);
}
beh->ActivateOutput(0);
beh->ActivateOutput(0);
}
return 0;
}
/*
*******************************************************************
* Function: int BehaviourFunction( const CKBehaviorContext& behaviorContext )
*
* Description : The execution function is the function that will be called
* during the process loop of the behavior engine, if the behavior
* is defined as using an execution function. This function is not
* called if the behavior is defined as a graph. This function is the
* heart of the behavior: it should compute the essence of the behavior,
* in an incremental way. The minimum amount of computing should be
* done at each call, to leave time for the other behaviors to run.
* The function receives the delay in milliseconds that has elapsed
* since the last behavioral process, and should rely on this value to
* manage the amount of effect it has on its computation, if the effect
* of this computation relies on time.
*
* Paramters :
* behaviourContext r Behavior context reference, which gives access to
* frequently used global objects ( context, level, manager, etc... )
*
* Returns : int, If it is done, it should return CKBR_OK. If it returns
* CKBR_ACTIVATENEXTFRAME, the behavior will again be called
* during the next process loop.
*
*******************************************************************
*/
int CGBLCHChatMoveHomogeneous::BehaviourFunction( const CKBehaviorContext& behaviorContext )
{
CKBehavior *beh = behaviorContext.Behavior;
CKContext *ctx = behaviorContext.Context;
CK2dEntity *chatFrame = (CK2dEntity *)beh->GetInputParameterObject(0);
if (chatFrame)
{
float left, top, right, bottom;
beh->GetInputParameterValue(3, &left);
beh->GetInputParameterValue(3, &top);
beh->GetInputParameterValue(2, &right);
right += left;
beh->GetInputParameterValue(1, &bottom);
bottom += top;
VxRect rect(left, top, right, bottom);
chatFrame->SetHomogeneousCoordinates ( 1 );
int res = chatFrame->SetHomogeneousRect ( rect );
if (res == 0)
{
beh->ActivateInput (0, 0);
beh->ActivateOutput (0);
}
else
{
beh->ActivateInput (0, 0);
beh->ActivateOutput (1);
}
}
else
{
beh->ActivateInput (0, 0);
beh->ActivateOutput (1);
}
return CKBR_OK;
}
CKERROR TextureSinusCallBackObject(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
switch(behcontext.CallbackMessage) {
#ifdef macintosh
case CKM_BEHAVIORLOAD:
{
CKMesh *mesh = (CKMesh*) beh->GetInputParameterObject(4);
if(!mesh)
return 0;
int nbvert = mesh->GetModifierUVCount();
// we get the saved uv's
DWORD *savedUV = (DWORD *) beh->GetLocalParameterWriteDataPtr(0);
for(int i=0; i<nbvert*2; i++) {
savedUV[i] = ENDIANSWAP32(savedUV[i]);
}
}
break;
#endif
case CKM_BEHAVIORATTACH:
{
// we get the mesh vertices
CKMesh *mesh = (CKMesh*) beh->GetInputParameterObject(4);
if(!mesh) return 0;
CKDWORD Stride;
VxUV *uvarray = (VxUV*) mesh->GetModifierUVs(&Stride);
int nbvert = mesh->GetModifierUVCount();
VxUV *savedUV;
savedUV = new VxUV[nbvert];
for(int i=0 ; i<nbvert ; i++, uvarray = (VxUV*)((BYTE*)uvarray + Stride) ) {
savedUV[i] = *uvarray;
}
beh->SetLocalParameterValue(0, savedUV, nbvert * sizeof(VxUV) );
delete[] savedUV;
}
break;
case CKM_BEHAVIORDETACH:
{
// we get the mesh vertices
if(!beh) return 0;
CKMesh *mesh = (CKMesh*) beh->GetInputParameterObject(4);
if(!mesh) return 0;
CKDWORD Stride;
VxUV *uvarray = (VxUV*) mesh->GetModifierUVs(&Stride);
int nbvert = mesh->GetModifierUVCount();
VxUV *savePos = (VxUV*) beh->GetLocalParameterWriteDataPtr(0);
if(!savePos) return 0;
for(int i=0 ; i<nbvert ; i++, uvarray = (VxUV*)((BYTE*)uvarray + Stride) ) {
*uvarray = savePos[i];
}
mesh->ModifierUVMove();
}
}
return CKBR_OK;
}
//************************************
// Method: PBPhysicalize
// FullName: PBPhysicalize
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PBPhysicalize(const CKBehaviorContext& behcontext)
{
using namespace vtTools::BehaviorTools;
using namespace vtTools;
using namespace vtTools::AttributeTools;
//////////////////////////////////////////////////////////////////////////
//basic parameters
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
//////////////////////////////////////////////////////////////////////////
//settings
int useDWorld; beh->GetLocalParameterValue(bbS_USE_DEFAULT_WORLD,&useDWorld);
// int useWorldSS; beh->GetLocalParameterValue(bbS_USE_WORLD_SLEEP_SETTINGS,&useWorldSS);
// int useWorldDS; beh->GetLocalParameterValue(bbS_USE_WORLD_DAMPING_SETTINGS,&useWorldDS);
int useWorldM; beh->GetLocalParameterValue(bbS_USE_WORLD_MATERIAL,&useWorldM);
int addAttributes; beh->GetLocalParameterValue(bbS_ADD_ATTRIBUTES,&addAttributes);
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *referenceObject = (CK3dEntity *) beh->GetTarget();
if( !referenceObject ) return CKBR_OWNERERROR;
//////////////////////////////////////////////////////////////////////////
//the world :
CK3dEntity*worldRef = NULL;
if (!useDWorld)
{
worldRef = (CK3dEntity *) beh->GetInputParameterObject(bbI_TargetWorld);
}
// the world :
pWorld *world=GetPMan()->getWorld(worldRef,referenceObject);
if (!world)
{
beh->ActivateOutput(0);
return 0;
}
pRigidBody*result = world->getBody(referenceObject);
if (result)
{
beh->ActivateOutput(0);
return 0;
}
//////////////////////////////////////////////////////////////////////////
//pick up some parameters :
int flags = GetInputParameterValue<int>(beh,bbI_Flags);
int hType = GetInputParameterValue<int>(beh,bbI_HullType);
float density = GetInputParameterValue<float>(beh,bbI_Density);
float skinWidth = GetInputParameterValue<float>(beh,bbI_SkinWidth);
int hierarchy = GetInputParameterValue<int>(beh,bbI_Hierachy);
float newDensity = GetInputParameterValue<float>(beh,bbI_NewDensity);
float totalMass = GetInputParameterValue<float>(beh,bbI_TotalMass);
VxVector massOffset = GetInputParameterValue<VxVector>(beh,bbI_MassShift);
VxVector shapeOffset = GetInputParameterValue<VxVector>(beh,bbI_ShapeShift);
//////////////////////////////////////////////////////////////////////////
// we remove the old physic attribute :
if (referenceObject->HasAttribute(GetPMan()->GetPAttribute()))
{
referenceObject->RemoveAttribute(GetPMan()->GetPAttribute());
}
referenceObject->SetAttribute(GetPMan()->GetPAttribute());
SetAttributeValue<int>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_HIRARCHY,&hierarchy);
SetAttributeValue<int>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_HULLTYPE,&hType);
SetAttributeValue<int>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_BODY_FLAGS,&flags);
SetAttributeValue<float>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_DENSITY,&density);
SetAttributeValue<float>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_NEW_DENSITY,&newDensity);
SetAttributeValue<float>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_TOTAL_MASS,&totalMass);
SetAttributeValue<VxVector>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_MASS_OFFSET,&massOffset);
//SetAttributeValue<VxVector>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_MASS_OFFSET,&massOffset);
CK_ID wID = world->getReference()->GetID();
AttributeTools::SetAttributeValue<CK_ID>(referenceObject,GetPMan()->GetPAttribute(),E_PPS_WORLD,&wID);
//////////////////////////////////////////////////////////////////////////
//Material :
if (!useWorldM)
{
if (referenceObject->HasAttribute(GetPMan()->att_surface_props))
{
referenceObject->RemoveAttribute(GetPMan()->att_surface_props);
}
referenceObject->SetAttribute(GetPMan()->att_surface_props);
CKParameterIn *pMatIn = beh->GetInputParameter(bbI_Material);
CKParameter *pMat = pMatIn->GetRealSource();
CKParameterOut* pout = referenceObject->GetAttributeParameter(GetPMan()->att_surface_props);
int error = pout->CopyValue(pMat);
pout->Update();
}
pRigidBody *body = pFactory::Instance()->createRigidBodyFull(referenceObject,worldRef);
if (body)
{
body->translateLocalShapePosition(shapeOffset);
}
//GetPMan()->checkWorlds();
if (!addAttributes)
{
referenceObject->RemoveAttribute(GetPMan()->GetPAttribute());
referenceObject->RemoveAttribute(GetPMan()->att_surface_props);
}
beh->ActivateOutput(0);
return 0;
}
int GeneralCameraOrbit(const CKBehaviorContext& behcontext,INPUTPROCESSFUNCTION InputFunction)
{
// Get the behavior
CKBehavior* beh = behcontext.Behavior;
float delta = behcontext.DeltaTime;
// Current state of the behavior
CKBOOL stopping;
// Indicates the behavior we are stopping if returns, stop otherwise
CKBOOL Returns = TRUE;
beh->GetLocalParameterValue(LOCAL_RETURN,&Returns);
// Stop Entrance, we stop
if (beh->IsInputActive(1))
{
// Set IO State
beh->ActivateInput(1,FALSE);
// A protection in case we stop the behavior before having started it
VxVector InitialAngles;
beh->GetLocalParameterValue(LOCAL_INIT,&InitialAngles);
// Get current position
VxVector RotationAngles;
beh->GetLocalParameterValue(LOCAL_ROT,&RotationAngles);
// Stopping Now
stopping = TRUE;
beh->SetLocalParameterValue(LOCAL_STOPPING,&stopping);
if ( !Returns || ((RotationAngles.x == 0) && (RotationAngles.y == 0)) ) {
beh->ActivateOutput(1,TRUE);
return CKBR_OK;
}
}
// Gets the current camera
CKCamera *Camera = (CKCamera *) beh->GetTarget();
if( !Camera ) return CKBR_OWNERERROR;
// Gets the target informations
VxVector TargetPosition;
beh->GetInputParameterValue(IN_TARGET_POS,&TargetPosition);
CK3dEntity* TargetRef = (CK3dEntity*)beh->GetInputParameterObject(IN_TARGET_REF);
//////////////////////////////////////////////
// Gets the input parameters of the behavior
//////////////////////////////////////////////
VxVector InitialAngles(0,0,0), RotationAngles(0,0,0);
// First entrance, sets the initial values here only
if (beh->IsInputActive(0))
{
// Sets IO State
beh->ActivateInput(0,FALSE);
beh->ActivateOutput(0,TRUE);
// Not Stopping
stopping = FALSE;
beh->SetLocalParameterValue(LOCAL_STOPPING,&stopping);
// Compute the Initial Angles, the radius
VxVector InitialPosition;
Camera->GetPosition(&InitialPosition, TargetRef);
InitialPosition -= TargetPosition;
InitialAngles.z = Magnitude(InitialPosition);
if ( InitialAngles.z == 0.0f ) {
InitialAngles.x = 0.0f;
InitialAngles.y = 0.0f;
}
else {
// Vertical Polar Angle
float d;
InitialPosition.Normalize();
d = DotProduct(InitialPosition,VxVector::axisY());
// bound the value of d to avoid errors due to precision.
if (d < -1)
d = -1;
else if (d > 1)
d = 1;
InitialAngles.y = acosf(d);
// Horizontal Polar Angle
InitialPosition.y = 0;
if ( (InitialPosition.x == 0.0f) && (InitialPosition.y == 0.0f) && (InitialPosition.z == 0.0f) )
InitialAngles.x = PI/2;
else {
InitialPosition.Normalize();
d = DotProduct(InitialPosition,VxVector::axisX());
// bound the value of d to avoid eroors due to precision.
if (d < -1)
d = -1;
else if (d > 1)
d = 1;
InitialAngles.x = acosf(d);
d = DotProduct(InitialPosition,VxVector::axisZ());
if (d < 0)
InitialAngles.x *= -1;
}
// In case the camera has the head down, we need to inverse the commands when we go
// Up otherwise, the user will have the feeling to turn on the wrong direction.
VxVector CamUp;
Camera->GetOrientation(NULL,&CamUp,NULL,NULL);
if ( CamUp.y < 0 )
{
InitialAngles.x += PI;
InitialAngles.y *= -1;
InitialAngles.x = (float)fmod(InitialAngles.x,2*PI);
}
}
// Reset stopping
stopping = FALSE;
// Sets the values in memory
beh->SetLocalParameterValue(LOCAL_INIT,&InitialAngles);
beh->SetLocalParameterValue(LOCAL_ROT,&RotationAngles);
beh->SetLocalParameterValue(LOCAL_STOPPING,&stopping);
// Only initialization on "On" entrance
return CKBR_ACTIVATENEXTFRAME;
}
// Auto-activation of the behavior
beh->GetLocalParameterValue(LOCAL_INIT,&InitialAngles);
beh->GetLocalParameterValue(LOCAL_ROT,&RotationAngles);
beh->GetLocalParameterValue(LOCAL_STOPPING,&stopping);
// Get the input manager
CKInputManager *input = (CKInputManager*)behcontext.Context->GetManagerByGuid(INPUT_MANAGER_GUID);
// Call the input processing function
InputFunction (&RotationAngles,beh,input,delta,Returns,stopping);
// Do nothing when initial angle were not initialized.
// Simply stop the BB. No output activated.
if ( (InitialAngles.x == INF) || (RotationAngles.x == INF) )
return CKBR_OK;
// When we are exactly on the top or the bottom of the target, +/-90°,
// The LookAt BB won't rotate the camera when we turn right or left as
// it already looks at the target. Therefore, when we are at +/-90°, we
// add or remove a little something.
if ( (RotationAngles.y==PI/2) || (RotationAngles.y == -PI/2) )
{
// Get Min, Max
// If equals, nothing to change, it is the given value.
float MinH = -PI/2;
float MaxH = PI/2;
beh->GetInputParameterValue(IN_MIN_H, &MinH);
beh->GetInputParameterValue(IN_MAX_H, &MaxH);
if ( MaxH - MinH > 2 * STEP )
{
float sign = (RotationAngles.y > 0) ? 1.0f : -1.0f;
if ( MaxH >= sign * PI/2 + STEP )
RotationAngles.y += STEP;
else
RotationAngles.y -= STEP;
}
}
// We memorize the new state with modulos
RotationAngles.x = (float)fmod(RotationAngles.x,2*PI);
RotationAngles.y = (float)fmod(RotationAngles.y,2*PI);
beh->SetLocalParameterValue(LOCAL_ROT,&RotationAngles);
// Computes the coordinates of the camera in the target referential thanks to the
// current polar angles and radius informations. And moves the camera
VxVector Position;
Position = InitialAngles + RotationAngles;
Position = Position.z * (cosf(Position.x) * sinf(Position.y) * VxVector::axisX() + sinf(Position.x) * sinf(Position.y) * VxVector::axisZ() + cosf(Position.y) * VxVector::axisY());
Position += TargetPosition;
Camera->SetPosition(&Position, TargetRef, FALSE);
// Does the camera has a Target ?
CK3dEntity *CameraTarget;
CKBOOL CameraHasTarget = CKIsChildClassOf(Camera,CKCID_TARGETCAMERA)
&& (CameraTarget=((CKTargetCamera*)Camera)->GetTarget());
// Orients the Camera. The LookAt implies that when the camera reach
// the 90°, it may be flipped and suddently have the head up and down.
// Therefore we use the target for target cameras as we have to use the
// target. But for free cameras, we do our own look at using our rotation
// angle to avoid this problem.
if (CameraHasTarget)
CameraTarget->SetPosition(&TargetPosition, TargetRef, TRUE);
else {
// New direction
VxVector Dir;
Dir = TargetPosition - Position;
// Temp Right Value
VxMatrix mat;
VxVector R(0,0,-1); // Up for (0,0) angle
Vx3DMatrixFromRotationAndOrigin(mat,VxVector::axisY(),VxVector(0,0,0),InitialAngles.x + RotationAngles.x);
R.Rotate(mat);
// Get Up
VxVector Up;
Up = CrossProduct(R,Dir);
Camera->SetOrientation(&Dir,&Up,NULL,TargetRef);
//Camera->LookAt(&TargetPosition,TargetRef);
}
// Stop is finished, reset values.
if ( stopping && ((RotationAngles.x == 0) && (RotationAngles.y == 0)) )
{
beh->ActivateOutput(1,TRUE);
return CKBR_OK;
}
else
// Come back next frame
return CKBR_ACTIVATENEXTFRAME;
}
/*
*******************************************************************
* Function: int BehaviourFunction( const CKBehaviorContext& behaviorContext )
*
* Description : The execution function is the function that will be called
* during the process loop of the behavior engine, if the behavior
* is defined as using an execution function. This function is not
* called if the behavior is defined as a graph. This function is the
* heart of the behavior: it should compute the essence of the behavior,
* in an incremental way. The minimum amount of computing should be
* done at each call, to leave time for the other behaviors to run.
* The function receives the delay in milliseconds that has elapsed
* since the last behavioral process, and should rely on this value to
* manage the amount of effect it has on its computation, if the effect
* of this computation relies on time.
*
* Parameters :
* behaviourContext r Behavior context reference, which gives access to
* frequently used global objects ( context, level, manager, etc... )
*
* Returns : int, If it is done, it should return CKBR_OK. If it returns
* CKBR_ACTIVATENEXTFRAME, the behavior will again be called
* during the next process loop.
*
*******************************************************************
*/
int CGBLCHPopulateAvailableRecipients::BehaviourFunction( const CKBehaviorContext& behaviorContext )
{
enum
{
GETACTIVEPLAYERSARRAY_COLUMN_VIRTOOLSUSERID,
GETACTIVEPLAYERSARRAY_COLUMN_USERNAME,
GETACTIVEPLAYERSARRAY_COLUMN_GBLTEAMID
};
enum
{
AVAILABLERECIPIENTSARRAY_COLUMN_USERNAME,
AVAILABLERECIPIENTSARRAY_COLUMN_VIRTOOLSUSERID,
AVAILABLERECIPIENTSARRAY_COLUMN_GBLTEAMID
};
CKBehavior *beh = behaviorContext.Behavior;
CGBLCOError localError(CGBLCOError::EGBLCOErrorType::GBLCO_OK);
if (!beh)
{
assert(NULL);
return CKBR_BEHAVIORERROR;
}
// Get profile controller
CGBLProfileManager* profileManager = static_cast<CGBLProfileManager*>(beh->GetCKContext()->GetManagerByGuid(GBLProfileManagerGUID));
if (!profileManager)
{
assert(NULL);
return CKBR_BEHAVIORERROR;
}
// Get GBL Loader manager
GBLLDManager* loaderManager = static_cast<GBLLDManager*>(beh->GetCKContext()->GetManagerByGuid(GBLLDManagerGUID));
if (!profileManager)
{
assert(NULL);
return CKBR_BEHAVIORERROR;
}
// Check we have been passed an array
CKDataArray* availableRecipientsArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputAvailableRecipientsArray));
if (!availableRecipientsArray)
{
return CKBR_BEHAVIORERROR;
}
// Clear array and set up structure
availableRecipientsArray->Clear();
while (availableRecipientsArray->GetColumnCount())
availableRecipientsArray->RemoveColumn(0);
availableRecipientsArray->InsertColumn(-1, CKARRAYTYPE_STRING, "Name");
availableRecipientsArray->InsertColumn(-1, CKARRAYTYPE_INT, "VirtoolsUserID");
availableRecipientsArray->InsertColumn(-1, CKARRAYTYPE_PARAMETER, "GBLTeamID", GUID_TEAM_ID);
// Create a temporary array of active players to be filled in by the Profile Controller
CKDataArray* tmpActivePlayersArray = (CKDataArray*)beh->GetCKContext()->CreateObject(CKCID_DATAARRAY,
"CGBLCHPopulateAvailableRecipients temp array",
CK_OBJECTCREATION_DYNAMIC);
if (!tmpActivePlayersArray)
{
assert(NULL);
return CKBR_BEHAVIORERROR;
}
// Create temporary array for team names to be filled in by the Profile Controller
CKDataArray* tmpTeamNameArray = (CKDataArray*)beh->GetCKContext()->CreateObject(CKCID_DATAARRAY,
"CGBLCHPopulateAvailableRecipients temp array 2",
CK_OBJECTCREATION_DYNAMIC);
if (!tmpTeamNameArray)
{
assert(NULL);
return CKBR_BEHAVIORERROR;
}
// Get active players
localError = profileManager->GetActivePlayers(tmpActivePlayersArray);
if (localError != CGBLCOError::EGBLCOErrorType::GBLCO_OK)
{
localError.SetCode(GBLCH_ERRORCODE_UNABLETOGETPROFILEINFORMATION);
localError.SetDescription((XString)"An error occurred while attempting to retrieve profile information: " + (const char*)localError);
}
else
{
// Collate Team IDs into local array
CGBLTeamID teamID;
XArray<CGBLTeamID> arrayOfTeamIDs;
XArray<XString> arrayOfTeamNames;
char* stringBuffer = NULL;
for (int row = 0;row < tmpActivePlayersArray->GetRowCount();row++)
{
// Get Team ID
teamID = 0;
if (tmpActivePlayersArray->GetElementValue(row, GETACTIVEPLAYERSARRAY_COLUMN_GBLTEAMID, &teamID))
{
if ((int)teamID)
{
// Have we already got this team ID in the array?
if (arrayOfTeamIDs.End() == arrayOfTeamIDs.Find(teamID))
{
// No, add it to the array
arrayOfTeamIDs.PushBack(teamID);
}
}
}
}
// Copy team IDs and names into AvailableRecipients array
for (int team = 0;team < arrayOfTeamIDs.Size();team++)
{
availableRecipientsArray->AddRow();
int row = availableRecipientsArray->GetRowCount() - 1;
assert(row == team);
// Get team name
teamID = arrayOfTeamIDs[team];
localError = profileManager->GetProfileField((const)teamID, "Name", tmpTeamNameArray);
if (localError != CGBLCOError::EGBLCOErrorType::GBLCO_OK) {
localError.SetCode(GBLCH_ERRORCODE_UNABLETOGETPROFILEINFORMATION);
localError.SetDescription((XString)"An error occurred while attempting to retrieve profile information: " + (const char*)localError);
break;
}
// Place team name into destination array
stringBuffer = new char[tmpTeamNameArray->GetElementStringValue(0, 0, NULL) + 1];
tmpTeamNameArray->GetElementStringValue(0, 0, stringBuffer);
availableRecipientsArray->SetElementStringValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_USERNAME, stringBuffer);
delete stringBuffer;
stringBuffer = NULL;
// Set user ID as 0
int virtoolsUserID = 0;
availableRecipientsArray->SetElementValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_VIRTOOLSUSERID, &virtoolsUserID);
// Set team ID
availableRecipientsArray->SetElementValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_GBLTEAMID, &arrayOfTeamIDs[team]);
}
}
if (localError == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
{
CGBLTeamID teamID;
char* stringBuffer = NULL;
int virtoolsUserID;
// Now copy players (which includes facilitators) into the destination array
for (int row = 0;row < tmpActivePlayersArray->GetRowCount();row++)
{
// Get User ID
virtoolsUserID = 0;
if (tmpActivePlayersArray->GetElementValue(row, GETACTIVEPLAYERSARRAY_COLUMN_VIRTOOLSUSERID, &virtoolsUserID))
{
// Check this user ID valid
if (virtoolsUserID)
{
// Add new row to destination array
availableRecipientsArray->AddRow();
int row = availableRecipientsArray->GetRowCount() - 1;
// Set Virtools user ID
availableRecipientsArray->SetElementValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_VIRTOOLSUSERID, &virtoolsUserID);
// Get name and put into dest array
stringBuffer = new char[tmpActivePlayersArray->GetElementStringValue(row, GETACTIVEPLAYERSARRAY_COLUMN_USERNAME, NULL) + 1];
tmpActivePlayersArray->GetElementStringValue(row, GETACTIVEPLAYERSARRAY_COLUMN_USERNAME, stringBuffer);
availableRecipientsArray->SetElementStringValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_USERNAME, stringBuffer);
delete stringBuffer;
stringBuffer = NULL;
// Set team ID to 0
teamID = 0;
availableRecipientsArray->SetElementValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_GBLTEAMID, &teamID);
}
}
}
}
if (localError == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
{
// Remove the current user from the array
// Get current Virtools User ID from GBL Loader
int currentVirtoolsUserID = loaderManager->GetVirtoolsUserID();
for (int row = availableRecipientsArray->GetRowCount() - 1;row >= 0;row--)
{
int virtoolsUserId = 0;
availableRecipientsArray->GetElementValue(row, AVAILABLERECIPIENTSARRAY_COLUMN_VIRTOOLSUSERID, &virtoolsUserId);
if (virtoolsUserId == currentVirtoolsUserID)
{
// This row is the current user. Remove it
availableRecipientsArray->RemoveRow(row);
}
}
}
// Free temporary arrays
beh->GetCKContext()->DestroyObject(tmpActivePlayersArray);
beh->GetCKContext()->DestroyObject(tmpTeamNameArray);
// Did an error occur?
if (localError == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
{
// Output success
beh->ActivateOutput(eBehOutputDone);
}
else
{
// Output the error
TGBLError::SetTGBLError(beh->GetOutputParameter(eParamOutputError), localError, localError, (CKSTRING)(const char*)localError);
beh->ActivateOutput(eBehOutputError);
}
// All done
return CKBR_OK;
}
int DOUserValueModified(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKMessageManager* mm = behcontext.MessageManager;
CKContext* ctx = behcontext.Context;
//////////////////////////////////////////////////////////////////////////
//connection id :
int connectionID = vtTools::BehaviorTools::GetInputParameterValue<int>(beh,0);
if (beh->IsInputActive(1))
{
beh->ActivateInput(1,FALSE);
beh->ActivateOutput(1);
return 0;
}
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *obj= (CK3dEntity*)beh->GetInputParameterObject(1);
if (!obj)
{
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
//////////////////////////////////////////////////////////////////////////
//network ok ?
xNetInterface *cin = GetNM()->GetClientNetInterface();
if (!cin)
{
CKParameterOut *pout = beh->GetOutputParameter(2);
XString errorMesg("distributed object creation failed,no network connection !");
pout->SetStringValue(errorMesg.Str());
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
//use objects name, if not specified :
CKSTRING name= obj->GetName();
IDistributedObjects*doInterface = cin->getDistObjectInterface();
IDistributedClasses*cInterface = cin->getDistributedClassInterface();
XString className((CKSTRING) beh->GetLocalParameterReadDataPtr(0));
XString parameterName((CKSTRING) beh->GetLocalParameterReadDataPtr(1));
xDistributedClass *_class = cInterface->get(className.CStr());
//////////////////////////////////////////////////////////////////////////
//dist class ok ?
if (_class==NULL)
{
beh->ActivateOutput(3);
ctx->OutputToConsoleEx("Distributed Class doesn't exists : %s",className.CStr());
return CKBR_ACTIVATENEXTFRAME;
}
const char * cNAme = _class->getClassName().getString();
int classType = _class->getEnitityType();
int bcount = beh->GetInputParameterCount();
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
xDistributedObject *dobjDummy = NULL;
xDistributedObject *dobj = doInterface->getByEntityID(obj->GetID());
if (!dobj)
{
beh->ActivateOutput(3);
return CKBR_ACTIVATENEXTFRAME;
}
if (dobj)
{
xDistributedProperty * prop = dobj->getUserProperty(parameterName.CStr());
if (prop)
{
if ( dobj->getGhostUpdateBits().testStrict(1 << prop->getBlockIndex()))
{
CKParameterManager *pam = static_cast<CKParameterManager *>(ctx->GetParameterManager());
CKParameterOut *ciIn = beh->GetOutputParameter(1);
CKParameterType pType = ciIn->GetType();
int sType = vtTools::ParameterTools::GetVirtoolsSuperType(ctx,pam->ParameterTypeToGuid(pType));
int userType = xDistTools::ValueTypeToSuperType(prop->getPropertyInfo()->mValueType);
if ( userType ==sType )
{
beh->ActivateOutput(2);
dobj->getGhostUpdateBits().set(1 << prop->getBlockIndex(),false);
switch(xDistTools::ValueTypeToSuperType(prop->getPropertyInfo()->mValueType))
{
case vtFLOAT:
{
xDistributedPoint1F *propValue = static_cast<xDistributedPoint1F*>(prop);
if (propValue)
{
float ovalue = propValue->mLastServerValue;
beh->SetOutputParameterValue(1,&ovalue);
break;
}
}
case vtVECTOR2D:
{
xDistributedPoint2F *propValue = static_cast<xDistributedPoint2F*>(prop);
if (propValue)
{
Point2F ovalue = propValue->mLastServerValue;
Vx2DVector ovaluex(ovalue.x,ovalue.y);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtVECTOR:
{
xDistributedPoint3F *propValue = static_cast<xDistributedPoint3F*>(prop);
if (propValue)
{
Point3F ovalue = propValue->mLastServerValue;
VxVector ovaluex(ovalue.x,ovalue.y,ovalue.z);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtQUATERNION:
{
xDistributedQuatF*propValue = static_cast<xDistributedQuatF*>(prop);
if (propValue)
{
QuatF ovalue = propValue->mLastServerValue;
VxQuaternion ovaluex(ovalue.x,ovalue.y,ovalue.z,ovalue.w);
beh->SetOutputParameterValue(1,&ovaluex);
break;
}
}
case vtSTRING:
{
xDistributedString*propValue = static_cast<xDistributedString*>(prop);
if (propValue)
{
TNL::StringPtr ovalue = propValue->mCurrentValue;
CKParameterOut *pout = beh->GetOutputParameter(1);
XString errorMesg(ovalue.getString());
pout->SetStringValue(errorMesg.Str());
break;
}
}
case vtINTEGER:
{
xDistributedInteger*propValue = static_cast<xDistributedInteger*>(prop);
if (propValue)
{
int ovalue = propValue->mLastServerValue;
beh->SetOutputParameterValue(1,&ovalue);
break;
}
}
}
}
}
}
}
return CKBR_ACTIVATENEXTFRAME;
if (beh->IsInputActive(0))
{
beh->ActivateOutput(0);
}
/*
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
if (beh->IsInputActive(0))
{
beh->ActivateOutput(0);
for (int i = BEH_IN_INDEX_MIN_COUNT ; i < beh->GetInputParameterCount() ; i++ )
{
beh->ActivateInput(0,FALSE);
xDistributedObject *dobj = doInterface->get(name);
if (!dobj)
{
beh->ActivateOutput(0);
return 0;
}
CKParameterIn *ciIn = beh->GetInputParameter(i);
CKParameterType pType = ciIn->GetType();
int sType = vtTools::ParameterTools::GetVirtoolsSuperType(ctx,pam->ParameterTypeToGuid(pType));
xDistributedPropertyArrayType &props = *dobj->getDistributedPorperties();
int propID = _class->getInternalUserFieldIndex(i - BEH_IN_INDEX_MIN_COUNT);
if (propID==-1 || propID > props.size() )
{
beh->ActivateOutput(1);
return 0;
}
xDistributedProperty *prop = props[propID];
if (prop)
{
xDistributedPropertyInfo*propInfo = prop->getPropertyInfo();
if (propInfo)
{
if (xDistTools::ValueTypeToSuperType(propInfo->mValueType) ==sType )
{
TNL::U32 currentTime = TNL::Platform::getRealMilliseconds();
switch(propInfo->mValueType)
{
case E_DC_PTYPE_3DVECTOR:
{
xDistributedPoint3F * dpoint3F = (xDistributedPoint3F*)prop;
if (dpoint3F)
{
VxVector vvalue;
beh->GetInputParameterValue(i,&vvalue);
bool update = dpoint3F->updateValue(xMath::getFrom(vvalue),currentTime);
}
break;
}
case E_DC_PTYPE_FLOAT:
{
xDistributedPoint1F * dpoint3F = (xDistributedPoint1F*)prop;
if (dpoint3F)
{
float vvalue;
beh->GetInputParameterValue(i,&vvalue);
bool update = dpoint3F->updateValue(vvalue,currentTime);
}
break;
}
}
}
}
}
}
beh->ActivateOutput(0);
}
*/
//////////////////////////////////////////////////////////////////////////
//we come in by loop :
return 0;
}
/*
*******************************************************************
* Function: RenderCallback()
*
* Description : Is called from Virtools every frame. We draw the widget's visual elements in this function.
*
* Parameters :
* Passed in from Virtools. See Virtools SDK documentation:
* *renderContext, rw:
* renderObject, rw:
* *iArg, rw:
*
* Returns : Return TRUE for success or FALSE for failure. The implications of returning FALSE are not documented in the Virtools
* SDK documentation. Let's hope it doesn't format the user's hard disk.
*
*******************************************************************
*/
CKBOOL CGBLListBox::RenderCallback(CKRenderContext *renderContext, CKRenderObject* renderObject, void *iArg)
{
const int cFixedStringBufferSize = 256;
static VxRect fullUVRect(0.0f, 0.0f, 1.0f, 1.0f);
CKContext* context = renderContext->GetCKContext();
CK2dEntity* ent = CK2dEntity::Cast(renderObject);
// Sanity check
if (!ent)
{
assert(NULL);
return FALSE;
}
// Get a pointer to the building block behaviour
CKBehavior* beh = (CKBehavior*)context->GetObject(reinterpret_cast<CK_ID>(iArg));
if (!beh)
return FALSE;
// Use clipping class to manage the clipping for us
CGBLRenderClipper cRenderClipper(renderContext, ent);
// Get client rectangle
VxRect clientRect;
ent->GetExtents(fullUVRect, clientRect);
// Get the font from the base helper class
VirtoolsSource::CKTextureFont* font = CGBLWidget::GetFont(context, beh);
if (!font)
{
// Don't output an error - we check for a font in the behavioural function
return FALSE;
}
// Get material
CKMaterial* material = (CKMaterial*)beh->GetInputParameterObject(eParamInputMaterial);
if (!material)
{
return FALSE;
}
// Are we using proportional scaling?
CKBOOL isPropScaling = CGBLWidget::IsProportionalScaling(beh);
// Get the font height
float fontHeight = CGBLWidget::GetFontHeight(font, renderContext, isPropScaling);
// Render down arrow
CKBOOL isDownButtonPressed = FALSE;
beh->GetLocalParameterValue(eLocalParamIsScrollDownButtonPressed, &isDownButtonPressed);
VxRect buttonRect = GetRectDownArrow(clientRect, fontHeight);
CGBLWidget::DrawMaterialRectangle(renderContext, material, buttonRect,
isDownButtonPressed ? CGBLWidgetsTheme::GetListBoxRegionDownArrowPressed() : CGBLWidgetsTheme::GetListBoxRegionDownArrowUnpressed(),
clientRect);
// Render up arrow
CKBOOL isUpButtonPressed = FALSE;
beh->GetLocalParameterValue(eLocalParamIsScrollUpButtonPressed, &isUpButtonPressed);
buttonRect = GetRectUpArrow(clientRect, fontHeight);
CGBLWidget::DrawMaterialRectangle(renderContext, material, buttonRect,
isUpButtonPressed ? CGBLWidgetsTheme::GetListBoxRegionUpArrowPressed() : CGBLWidgetsTheme::GetListBoxRegionUpArrowUnpressed(),
clientRect);
// Render headings if present
// Get columns array
CKDataArray* columnsArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputColumnsArray));
int numColumns = columnsArray ? columnsArray->GetRowCount() : 1;
// If we have at least one row in the columns array, we are drawing headings
if (columnsArray && (columnsArray->GetRowCount() >= 1))
{
VxRect headingsRect = GetRectHeadings(clientRect, fontHeight, columnsArray);
VxRect headingRect = headingsRect;
for (int column = 0;column < numColumns;column++)
{
headingRect.right = headingRect.left + GetColumnWidth(beh, columnsArray, column) * headingsRect.GetWidth() / 100.0f;
// Draw heading background
CGBLWidget::DrawMaterialRectangle(renderContext, material, headingRect,
CGBLWidgetsTheme::GetListBoxRegionHeadingBackground(), headingsRect);
// Draw heading text
CKCHAR fixedBuffer[cFixedStringBufferSize];
CKSTRING headingText = NULL;
int labelLength = columnsArray->GetElementStringValue(column, eColumnsArrayColumnHeading, NULL);
if (labelLength > cFixedStringBufferSize)
headingText = new CKCHAR[labelLength];
else
headingText = fixedBuffer;
if (headingText)
{
columnsArray->GetElementStringValue(column, eColumnsArrayColumnHeading, headingText);
int textOptions = TEXT_CLIP;
if (isPropScaling)
textOptions |= TEXT_SCREEN;
VxRect clippedHeadingRect = headingRect;
clippedHeadingRect.Clip(headingsRect);
// Use margin
clippedHeadingRect.left += CGBLWidgetsTheme::GetStringListBoxTextMargin() * fontHeight;
font->DrawCKText(renderContext, ent, headingText, VALIGN_BOTTOM | HALIGN_LEFT, clippedHeadingRect, NULL, textOptions, TRUE);
// Delete the buffer?
if (headingText != fixedBuffer)
delete[] headingText;
}
// Move to next heading
headingRect.left = headingRect.right;
}
}
// Get data array and output error if we don't have one
CKDataArray* stringListArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputStringListArray));
if (!stringListArray)
return FALSE;
// Get space for list box strings area
VxRect stringListRect = GetRectStringList(clientRect, fontHeight, columnsArray);
// Draw columns backgrounds now
VxRect columnRect = stringListRect;
for (int column = 0;column < numColumns;column++)
{
columnRect.right = columnRect.left + GetColumnWidth(beh, columnsArray, column) * stringListRect.GetWidth() / 100.0f;
// Draw column background
CGBLWidget::DrawMaterialRectangle(renderContext, material, columnRect,
CGBLWidgetsTheme::GetListBoxRegionColumnBackground(), stringListRect);
// Move to next column
columnRect.left = columnRect.right;
}
// Get the scroll offset
int scrollOffset = 0;
beh->GetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
// Range check the scroll offset
int nRowsVisible = static_cast<int>(stringListRect.GetHeight() / fontHeight + 0.01); // Add fudge factor to avoid rounding down errors
if ((scrollOffset + nRowsVisible - 1) >= stringListArray->GetRowCount())
scrollOffset = stringListArray->GetRowCount() - nRowsVisible;
if (scrollOffset < 0)
scrollOffset = 0;
// Re-set scroll offset local param
beh->SetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
// Draw any selection highlights
VxRect rowRect;
for (int row = scrollOffset;
CGBLWidget::GetListRowRect(stringListRect, row, scrollOffset, stringListArray->GetRowCount(), fontHeight, &rowRect); row++)
{
CKBOOL rowSelected = FALSE;
stringListArray->GetElementValue(row, CGBLWidget::eStringListArrayColumnSelected, &rowSelected);
if (rowSelected)
CGBLWidget::DrawMaterialRectangle(renderContext, material, rowRect, CGBLWidgetsTheme::GetListBoxRegionSelectedBackground());
}
// Draw column strings now
columnRect = stringListRect;
for (int column = 0;column < numColumns;column++)
{
columnRect.right = columnRect.left + GetColumnWidth(beh, columnsArray, column) * stringListRect.GetWidth() / 100.0f;
// Select which column to pick from the string list array
int arrayColumn;
if (column)
arrayColumn = column + CGBLWidget::eStringListArrayColumnAdditionalLabels - 1;
else
arrayColumn = column;
VxRect clippedColumnRect = columnRect;
clippedColumnRect.Clip(stringListRect);
CGBLWidget::DrawStringListColumn(renderContext, ent, font, isPropScaling, stringListArray,
arrayColumn, clippedColumnRect, scrollOffset, column == 0);
// Move to next column
columnRect.left = columnRect.right;
}
// Disable the scroll buttons?
if (scrollOffset == 0)
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectUpArrow(clientRect, fontHeight), clientRect);
if ((scrollOffset + nRowsVisible) > (stringListArray->GetRowCount() - 1) )
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectDownArrow(clientRect, fontHeight), clientRect);
CKBOOL isFocussed = CGBLWidget::IsWidgetFocussed(beh);
// If we're focussed, draw a focus rectangle around our focussed item
if (isFocussed)
{
int focussedItem = 0;
beh->GetLocalParameterValue(eLocalParamFocussedItem, &focussedItem);
if (CGBLWidget::GetListRowRect(stringListRect, focussedItem, scrollOffset, stringListArray->GetRowCount(), fontHeight, &rowRect))
{
// draw focus around the selected item
CGBLWidget::DrawFocusHighlight(renderContext, beh, rowRect, FALSE);
}
else
{
// see if the list is empty
if ((!stringListArray)||(stringListArray->GetRowCount()<=0))
{
// Draw focus around the full list box
CGBLWidget::DrawFocusHighlight(renderContext, beh, clientRect, FALSE);
}
else
{
// The list isnt empty but the current item is unselectable
}
}
}
// If widget is disabled, draw whole widget area disabled
if (!CGBLWidget::IsWidgetEnabled(beh))
{
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectUpArrow(clientRect, fontHeight), clientRect);
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectDownArrow(clientRect, fontHeight), clientRect);
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectHeadings(clientRect, fontHeight, columnsArray), clientRect);
CGBLWidget::DrawDisabledRectangle(renderContext, GetRectStringList(clientRect, fontHeight, columnsArray), clientRect);
}
return TRUE;
}
//************************************
// Method: PBPhysicalizeEx
// FullName: PBPhysicalizeEx
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PBPhysicalizeEx(const CKBehaviorContext& behcontext)
{
using namespace vtTools::BehaviorTools;
using namespace vtTools;
using namespace vtTools::AttributeTools;
using namespace vtTools::ParameterTools;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
//
// objects
//
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
//the object :
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
if( !target ) bbErrorME("No Reference Object specified");
//the world reference, optional used
CK3dEntity*worldRef = NULL;
//the world object, only used when reference has been specified
pWorld *world = NULL;
//final object description
pObjectDescr *oDesc = new pObjectDescr();
pRigidBody *body = NULL;
XString errMesg;
//----------------------------------------------------------------
//
// sanity checks
//
// rigid body
GetPMan()->getBody(target);
if( body){
errMesg.Format("Object %s already registered.",target->GetName());
bbErrorME(errMesg.Str());
}
//----------------------------------------------------------------
//
//
//
if (!GetPMan()->isValid())
GetPMan()->performInitialization();
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
//
// Collecting data. Stores all settings in a pObjectDescr.
//
//get the parameter array
BB_DECLARE_PIMAP;
//----------------------------------------------------------------
//
// generic settings
//
oDesc->hullType = (HullType)GetInputParameterValue<int>(beh,bbI_HullType);
oDesc->flags = (BodyFlags)GetInputParameterValue<int>(beh,bbI_Flags);
oDesc->density = GetInputParameterValue<float>(beh,bbI_Density);
//----------------------------------------------------------------
// optional
// world
//
BBSParameterM(bbI_World,BB_SSTART);
if (sbbI_World)
{
worldRef = (CK3dEntity *) beh->GetInputParameterObject(BB_IP_INDEX(bbI_World));
if (worldRef)
{
world = GetPMan()->getWorld(worldRef,target);
if (!world)
{
xLogger::xLog(ELOGERROR,E_LI_MANAGER,"World reference has been specified but no valid world object found. Switching to default world");
goto errorFound;
}
}
}
//----------------------------------------------------------------
// optional
// Pivot
//
BBSParameterM(bbI_Pivot,BB_SSTART);
if (sbbI_Pivot)
{
CKParameter*pivotParameter = beh->GetInputParameter(BB_IP_INDEX(bbI_Pivot))->GetRealSource();
if (pivotParameter)
{
IParameter::Instance()->copyTo(oDesc->pivot,pivotParameter);
oDesc->mask |= OD_Pivot;
}
}
//----------------------------------------------------------------
// optional
// mass
//
BBSParameterM(bbI_Mass,BB_SSTART);
if (sbbI_Mass)
{
CKParameter*massParameter = beh->GetInputParameter(BB_IP_INDEX(bbI_Mass))->GetRealSource();
if (massParameter)
{
IParameter::Instance()->copyTo(oDesc->mass,massParameter);
oDesc->mask |= OD_Mass;
}
}
//----------------------------------------------------------------
// optional
// collision
//
BBSParameterM(bbI_Collision , BB_SSTART);
if (sbbI_Collision)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_Collision))->GetRealSource();
if (par)
{
oDesc->collisionGroup = GetValueFromParameterStruct<int>(par,PS_BC_GROUP,false);
CKParameterOut* maskPar = GetParameterFromStruct(par,PS_BC_GROUPSMASK);
if (maskPar)
{
oDesc->groupsMask.bits0 = GetValueFromParameterStruct<int>(maskPar,0);
oDesc->groupsMask.bits1 = GetValueFromParameterStruct<int>(maskPar,1);
oDesc->groupsMask.bits2 = GetValueFromParameterStruct<int>(maskPar,2);
oDesc->groupsMask.bits3 = GetValueFromParameterStruct<int>(maskPar,3);
}
oDesc->skinWidth = GetValueFromParameterStruct<float>(par,PS_BC_SKINWITDH,false);
IParameter::Instance()->copyTo(oDesc->collision,par);
oDesc->mask |= OD_Collision;
}
}
//----------------------------------------------------------------
// optional
// collision : CCD
//
BBSParameterM(bbI_CCD, BB_SSTART);
if (sbbI_CCD)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_CCD))->GetRealSource();
if (par)
{
IParameter::Instance()->copyTo(oDesc->ccd,par);
oDesc->mask |= OD_CCD;
}
}
//----------------------------------------------------------------
// optional
// optimization
//
BBSParameterM(bbI_Optimization, BB_SSTART);
if (sbbI_Optimization)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_Optimization))->GetRealSource();
if (par)
{
IParameter::Instance()->copyTo(oDesc->optimization,par);
oDesc->mask |= OD_Optimization;
}
}
//----------------------------------------------------------------
// optional
// Material
//
BBSParameterM(bbI_Material, BB_SSTART);
if (sbbI_Material)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_Material))->GetRealSource();
if (par)
{
pFactory::Instance()->copyTo(oDesc->material,par);
oDesc->mask |= OD_Material;
}
}
//----------------------------------------------------------------
// optional
// capsule
//
BBSParameterM(bbI_Capsule, BB_SSTART);
if (sbbI_Capsule)
{
if (oDesc->hullType == HT_Capsule)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_Capsule))->GetRealSource();
if (par)
{
IParameter::Instance()->copyTo(oDesc->capsule,par);
oDesc->mask |= OD_Capsule;
}
}else{
errMesg.Format("You attached a capsule parameter but the hull type is not capsule");
bbWarning(errMesg.Str());
}
}
//----------------------------------------------------------------
// optional
// convex cylinder
//
BBSParameterM(bbI_CCylinder, BB_SSTART);
if (sbbI_CCylinder)
{
if (oDesc->hullType == HT_ConvexCylinder)
{
CKParameter*par = beh->GetInputParameter(BB_IP_INDEX(bbI_CCylinder))->GetRealSource();
if (par)
{
pFactory::Instance()->copyTo(oDesc->convexCylinder,par,true);
oDesc->mask |= OD_ConvexCylinder;
}
}else{
errMesg.Format("You attached a convex cylinder parameter but the hull type is not a convex cylinder");
bbWarning(errMesg.Str());
}
}
oDesc->version = pObjectDescr::E_OD_VERSION::OD_DECR_V1;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
//
// body creation
//
if (!body)
{
if(! (oDesc->flags & BF_SubShape) )
{
body = pFactory::Instance()->createRigidBody(target,*oDesc);
}
}
if (!body)
{
SAFE_DELETE(oDesc);
bbErrorME("No Reference Object specified");
}
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
//
// attribute creation, attach settings
//
if (oDesc->flags & BF_AddAttributes )
{
//body->saveToAttributes(oDesc);
GetPMan()->copyToAttributes(*oDesc,target);
}
//----------------------------------------------------------------
//
// update input parameters
//
if (sbbI_Material)
{
CKParameterOut *par = (CKParameterOut*)beh->GetInputParameter(BB_IP_INDEX(bbI_Material))->GetRealSource();
if (par)
{
pFactory::Instance()->copyTo(par,oDesc->material);
}
}
//----------------------------------------------------------------
//
// cleanup
//
//SAFE_DELETE(oDesc);
//----------------------------------------------------------------
//
// error out
//
errorFound:
{
beh->ActivateOutput(0);
return CKBR_GENERICERROR;
}
//----------------------------------------------------------------
//
// All ok
//
allOk:
{
beh->ActivateOutput(0);
return CKBR_OK;
}
return 0;
}
//************************************
// Method: JD6SetParameters
// FullName: JD6SetParameters
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int JD6SetParameters(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
if( beh->IsInputActive(0) )
{
beh->ActivateInput(0,FALSE);
//////////////////////////////////////////////////////////////////////////
//the object A:
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
CK3dEntity *targetB = (CK3dEntity *) beh->GetInputParameterObject(0);
if (!pFactory::Instance()->jointCheckPreRequisites(target,targetB,JT_D6))
{
return CK_OK;
}
// the world :
pWorld *worldA=GetPMan()->getWorldByBody(target);
pWorld *worldB=GetPMan()->getWorldByBody(targetB);
if (!worldA)
{
worldA = worldB;
}
if (!worldA)
{
beh->ActivateOutput(0);
return 0;
}
// the physic object A :
pRigidBody*bodyA= worldA->getBody(target);
pRigidBody*bodyB= worldA->getBody(targetB);
if(bodyA || bodyB)
{
pJointD6 *joint =static_cast<pJointD6*>(worldA->getJoint(target,targetB,JT_D6));
VxVector linVel = GetInputParameterValue<VxVector>(beh,1);
VxVector aVel = GetInputParameterValue<VxVector>(beh,2);
VxVector pos = GetInputParameterValue<VxVector>(beh,3);
VxQuaternion rot = GetInputParameterValue<VxQuaternion>(beh,4);
float ratio = GetInputParameterValue<float>(beh,5);
joint->setDriveLinearVelocity(linVel);
joint->setDriveAngularVelocity(aVel);
joint->setRatio(ratio);
joint->setDrivePosition(pos);
joint->setDriveRotation(rot);
}
beh->ActivateOutput(0);
}
return 0;
}
//************************************
// Method: PJRevolute
// FullName: PJRevolute
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PJRevolute(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
if( beh->IsInputActive(0) )
{
beh->ActivateInput(0,FALSE);
//////////////////////////////////////////////////////////////////////////
//the object A:
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
CK3dEntity *targetB = (CK3dEntity *) beh->GetInputParameterObject(bI_ObjectB);
if (!pFactory::Instance()->jointCheckPreRequisites(target,targetB,JT_Revolute))
{
return CK_OK;
}
// the world :
pWorld *worldA=GetPMan()->getWorldByBody(target);
pWorld *worldB=GetPMan()->getWorldByBody(targetB);
if (!worldA && ! worldB )
{
return 0;
}
if (!worldA)
{
worldA = worldB;
}
if (!worldA)
{
beh->ActivateOutput(0);
return 0;
}
// the physic object A :
pRigidBody*bodyA= worldA->getBody(target);
pRigidBody*bodyB= worldA->getBody(targetB);
//anchor :
VxVector anchor = GetInputParameterValue<VxVector>(beh,bI_Anchor);
VxVector anchorOut = anchor;
CK3dEntity*anchorReference = (CK3dEntity *) beh->GetInputParameterObject(bI_AnchorRef);
if (anchorReference)
{
anchorReference->Transform(&anchorOut,&anchor);
}
//swing axis
VxVector Axis = GetInputParameterValue<VxVector>(beh,bI_Axis);
VxVector axisOut = Axis;
CK3dEntity*axisReference = (CK3dEntity *) beh->GetInputParameterObject(bI_AxisRef);
if (axisReference)
{
VxVector dir,up,right;
axisReference->GetOrientation(&dir,&up,&right);
axisReference->TransformVector(&axisOut,&up);
}
//////////////////////////////////////////////////////////////////////////
//limit high :
pJointLimit limitH;
pJointLimit limitL;
DWORD limit;
beh->GetLocalParameterValue(1,&limit);
if (limit)
{
CKParameterIn *par = beh->GetInputParameter(bbI_HighLimit);
if (par)
{
CKParameter *rPar = par->GetRealSource();
if (rPar)
{
limitH = pFactory::Instance()->createLimitFromParameter(rPar);
}
}
}
if (limit)
{
CKParameterIn *par = beh->GetInputParameter(bbI_LowLimit);
if (par)
{
CKParameter *rPar = par->GetRealSource();
if (rPar)
{
limitL = pFactory::Instance()->createLimitFromParameter(rPar);
}
}
}
//////////////////////////////////////////////////////////////////////////
DWORD spring;
pSpring sSpring;
beh->GetLocalParameterValue(0,&spring);
if (spring)
{
CKParameterIn *par = beh->GetInputParameter(bbI_Spring);
if (par)
{
CKParameter *rPar = par->GetRealSource();
if (rPar)
{
sSpring = pFactory::Instance()->createSpringFromParameter(rPar);
}
}
}
pMotor motor;
DWORD hasMotor;
beh->GetLocalParameterValue(2,&hasMotor);
if (hasMotor)
{
CKParameterIn *par = beh->GetInputParameter(bbI_Motor);
if (par)
{
CKParameter *rPar = par->GetRealSource();
if (rPar)
{
motor = pFactory::Instance()->createMotorFromParameter(rPar);
}
}
}
int col = GetInputParameterValue<int>(beh,bbI_Collision);
ProjectionMode mode =GetInputParameterValue<ProjectionMode>(beh,bbI_PMode);
float distance = GetInputParameterValue<float>(beh,bbI_PDistance);
float angle= GetInputParameterValue<float>(beh,bbI_PAngle);
//////////////////////////////////////////////////////////////////////////
//
pJointRevolute *joint = static_cast<pJointRevolute*>(worldA->getJoint(target,targetB,JT_Revolute));
if(bodyA || bodyB)
{
//////////////////////////////////////////////////////////////////////////
//joint create ?
if (!joint)
{
joint = static_cast<pJointRevolute*>(pFactory::Instance()->createRevoluteJoint(target,targetB,anchorOut,axisOut));
}
////////////////////////////////////////////////////////////////////////// Modification :
if (joint)
{
joint->setGlobalAxis(axisOut);
joint->setGlobalAnchor(anchorOut);
if (mode!=0)
{
joint->setProjectionMode(mode);
joint->setProjectionDistance(distance);
joint->setProjectionAngle(angle);
}
//////////////////////////////////////////////////////////////////////////
if(limit)
{
joint->setHighLimit(limitH);
joint->setLowLimit(limitL);
}
//////////////////////////////////////////////////////////////////////////
if (spring)
{
joint->setSpring(sSpring);
}
if (hasMotor)
{
joint->setMotor(motor);
}
joint->enableCollision(col);
}
}
beh->ActivateOutput(0);
}
return 0;
}
//************************************
// Method: PWOverlapSphere
// FullName: PWOverlapSphere
// Access: public
// Returns: int
// Qualifier:
// Parameter: const CKBehaviorContext& behcontext
//************************************
int PWOverlapSphere(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
PhysicManager *pm = GetPMan();
pFactory *pf = pFactory::Instance();
using namespace vtTools::BehaviorTools;
using namespace vtTools::ParameterTools;
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *target = (CK3dEntity *) beh->GetTarget();
if( !target ) return CKBR_OWNERERROR;
//////////////////////////////////////////////////////////////////////////
// the world :
pWorld *world=GetPMan()->getWorld(target->GetID());
if (!world)
{
beh->ActivateOutput(bbOT_No);
return 0;
}
NxScene *scene = world->getScene();
if (!scene)
{
beh->ActivateOutput(bbOT_No);
return 0;
}
if( beh->IsInputActive(0) )
{
beh->ActivateInput(0,FALSE);
CKGroup *carray = (CKGroup*)beh->GetLocalParameterObject(bbS_Result);
if (carray)
{
//carray->clear();
carray->Clear();
}else
{
CK_OBJECTCREATION_OPTIONS creaoptions = (CK_OBJECTCREATION_OPTIONS)(CK_OBJECTCREATION_NONAMECHECK|CK_OBJECTCREATION_DYNAMIC);
carray = (CKGroup*)ctx()->CreateObject(CKCID_GROUP,"asdasd",creaoptions);
}
beh->SetLocalParameterObject(0,carray);
int hitIndex = 0;
beh->SetLocalParameterValue(bbS_Index,&hitIndex);
int hitSize = 0;
beh->SetLocalParameterValue(bbS_Size,&hitSize);
//////////////////////////////////////////////////////////////////////////
int types = GetInputParameterValue<int>(beh,bbI_ShapesType);
int accurate = GetInputParameterValue<int>(beh,bbI_Accurate);
DWORD groupsEnabled;
DWORD groups = 0xffffffff;
beh->GetLocalParameterValue(bbS_Groups,&groupsEnabled);
if (groupsEnabled)
{
groups = GetInputParameterValue<int>(beh,bbI_Groups);
}
pGroupsMask *gmask = NULL;
DWORD mask;
beh->GetLocalParameterValue(bbS_Mask,&mask);
if (mask)
{
CKParameter *maskP = beh->GetInputParameter(bbI_Mask)->GetRealSource();
gmask->bits0 = GetValueFromParameterStruct<int>(maskP,0);
gmask->bits1 = GetValueFromParameterStruct<int>(maskP,1);
gmask->bits2 = GetValueFromParameterStruct<int>(maskP,2);
gmask->bits3 = GetValueFromParameterStruct<int>(maskP,3);
}
float radius = GetInputParameterValue<float>(beh,bbI_Radius);
VxVector center = GetInputParameterValue<VxVector>(beh,bbI_Center);
VxSphere sphere(center,radius);
CK3dEntity *shape = (CK3dEntity*)beh->GetInputParameterObject(bbI_Ref);
int nbShapes = world->overlapSphereShapes(sphere,shape,(pShapesType)types,carray,groups,gmask,accurate);
if (nbShapes)
{
beh->ActivateOutput(bbOT_Yes);
beh->ActivateInput(1,TRUE);
}else{
beh->ActivateOutput(bbOT_No);
}
}
if( beh->IsInputActive(1) )
{
beh->ActivateInput(1,FALSE);
CKGroup *carray = (CKGroup*)beh->GetLocalParameterObject(bbS_Result);
//////////////////////////////////////////////////////////////////////////
if (carray)
{
if (carray->GetObjectCount())
{
CKBeObject *hit = carray->GetObject(carray->GetObjectCount()-1);
if (hit)
{
beh->SetOutputParameterObject(0,hit);
carray->RemoveObject(hit);
if (carray->GetObjectCount())
{
beh->ActivateOutput(bbOT_Next);
}else
{
beh->ActivateOutput(bbOT_Finish);
CKDestroyObject(carray);
}
}
}else{
beh->ActivateOutput(bbOT_Finish);
CKDestroyObject(carray);
}
}else
{
beh->ActivateOutput(bbOT_Finish);
CKDestroyObject(carray);
}
}
return 0;
}
int ARTPlusPatternTransformation(const CKBehaviorContext& BehContext)
{
CKBehavior* beh = BehContext.Behavior;
CKBOOL detected = FALSE;
int patternID = -1;
int markerId = -1;
float buffer[16];
float patternWidth = 8.0f;
CK3dEntity* Object = NULL;
VxQuaternion quat = VxQuaternion();
VxVector pos = VxVector();
VxVector scale = VxVector();
float gl_para[4][4] = { {1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f} };
float gl_tmp[4][4] = { {0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 0.0f} };
float koordSys[4][4] = { {1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f} };
float koordSys2[4][4] = { {1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f} };
beh->ActivateInput(0, FALSE);
beh->ActivateOutput(0);
if(ARTPlusInitialized == true)
{
// get object
Object = CK3dEntity::Cast(beh->GetInputParameterObject(IN_OBJECT));
if(Object==NULL) return CKBR_BEHAVIORERROR;
if(markerInfo!=NULL && numMarkers>0)
{
// Get pattern id
beh->GetInputParameterValue(IN_PATTERN_NUMBER, &patternID);
// Get pattern width
beh->GetInputParameterValue(IN_PATTERN_WIDTH, &patternWidth);
// define size of the marker
tracker->setPatternWidth(patternWidth);
markerId = findMarker(patternID);
if( markerId>=0 && markerInfo[markerId].id==patternID)
{
ARFloat patt_center[2] = {0.0f, 0.0f};
tracker->calcOpenGLMatrixFromMarker(&markerInfo[markerId], patt_center, patternWidth, (float *)buffer);
detected = TRUE;
for( int j = 0; j < 4; j++ )
{
for( int i = 0; i < 4; i++ )
{
gl_para[j][i] = buffer[j*4+i];
}
}
for( int j = 0; j < 4; j++ )
{
for( int i = 0; i < 4; i++ )
{
gl_tmp[j][i] = 0.0;
for(int k=0 ; k<4 ; k++)
{
gl_tmp[j][i] += koordSys[j][k]*gl_para[k][i];
}
}
}
for( int j = 0; j < 4; j++ )
{
for( int i = 0; i < 4; i++ )
{
gl_para[j][i] = 0.0;
for(int k=0 ; k<4 ; k++)
{
gl_para[j][i] += gl_tmp[j][k]*koordSys2[k][i];
}
}
}
}
}
VxMatrix mat = VxMatrix(gl_para);
Vx3DDecomposeMatrix(mat, quat, pos, scale);
// Set true, if marker is detected
beh->SetOutputParameterValue(OUT_DETECTED, &detected, 0);
// Set marker id
beh->SetOutputParameterValue(OUT_MARKERID, &patternID, 0);
// Set Position
beh->SetOutputParameterValue(OUT_POSITION, &pos, 0);
// Set quaternion
beh->SetOutputParameterValue(OUT_QUATERNION, &quat, 0);
// Set matrix
beh->SetOutputParameterValue(OUT_TRANSFORM_MATRIX, &mat, 0);
//Check object visibility
if(detected==TRUE)
{
// Transform object
Object->SetPosition(&pos, NULL, FALSE);
Object->SetQuaternion(&quat, NULL, FALSE, FALSE);
Object->Show(CKSHOW);
}
else
{
Object->Show(CKHIERARCHICALHIDE);
}
}
return CKBR_OK;
}
/*
*******************************************************************
* Function: BehaviourFunction()
*
* Description : Is called every frame from Virtools. Executes the behaviour of the BB.
*
* Parameters :
* behContext, r: Passed in from Virtools
*
* Returns : A CKBR_... return value
*
*******************************************************************
*/
int CGBLListBox::BehaviourFunction(const CKBehaviorContext& behContext)
{
static VxRect fullUVRect(0.0f, 0.0f, 1.0f, 1.0f);
// The default return code is CKBR_ACTIVATENEXTFRAME which forces BehaviourFunction() to be called next frame
CK_BEHAVIOR_RETURN behReturn = CKBR_ACTIVATENEXTFRAME;
CKBehavior* beh = behContext.Behavior;
// Call the helper class to implement our base class functionality
// If it returns FALSE, we must return the error code and not perform any behavioural functionality
CKBOOL isFocussed = FALSE;
if (!CGBLWidget::ExecuteBaseBehaviour(behContext, &isFocussed, &behReturn))
{
return behReturn;
}
// Check for mouse and keyboard inputs
CKInputManager* inputManager = (CKInputManager*)behContext.Context->GetManagerByGuid(INPUT_MANAGER_GUID);
if (!inputManager)
{
assert(NULL);
return CKBR_OK;
}
// Get material
CKMaterial* material = (CKMaterial*)beh->GetInputParameterObject(eParamInputMaterial);
if (!material)
{
// Output an error - we need a material
CGBLWidget::OutputBBErrorMsg(beh, "Please attach a material to the building block");
return CKBR_OK;
}
// Get font
VirtoolsSource::CKTextureFont* font = CGBLWidget::GetFont(behContext.Context, beh);
if (!font)
{
// Output an error - we need a font attached
CGBLWidget::OutputBBErrorMsg(beh, "Please attach a font to the building block");
return CKBR_OK;
}
// Are we using proportional scaling?
CKBOOL isPropScaling = CGBLWidget::IsProportionalScaling(beh);
// Get the font height
CKRenderContext* renderContext = behContext.Context->GetPlayerRenderContext();
float fontHeight = CGBLWidget::GetFontHeight(font, renderContext, isPropScaling);
// Get columns array, doesn't matter if we can't get it
CKDataArray* columnsArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputColumnsArray));
int numColumns = columnsArray ? columnsArray->GetRowCount() : 1;
CKSTRING errMsg = ValidateColumnsArray(columnsArray);
if (errMsg)
{
CGBLWidget::OutputBBErrorMsg(beh, errMsg);
return CKBR_OK;
}
// Get the string list array and check it's of the right type
CKDataArray* stringListArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputStringListArray));
errMsg = CGBLWidget::ValidateStringListArray(stringListArray, numColumns - 1);
if (errMsg)
{
CGBLWidget::OutputBBErrorMsg(beh, errMsg);
return CKBR_OK;
}
CKBeObject* beObject = beh->GetTarget();
CKRenderObject* renderObject = CKRenderObject::Cast(beObject);
// Add a render callback to allow our widget to render itself next frame
renderObject->AddPostRenderCallBack(RenderCallback, (void *)behContext.Behavior->GetID(), TRUE);
CK2dEntity* ent = CK2dEntity::Cast(renderObject);
VxRect clientRect;
ent->GetExtents(fullUVRect, clientRect);
// Check for Select b-in
if (beh->IsInputActive(eBehInputSelect))
{
// Reset b-in
beh->ActivateInput(eBehInputSelect, FALSE);
int select = 0;
beh->GetInputParameterValue(eParamInputSelectedItem, &select);
// Check we are in single selection mode
int selectionType = 0;
beh->GetLocalParameterValue(eLocalParamSelectionType, &selectionType);
if (selectionType == eSelectionTypeSingleSelection)
{
// Is this row selectable?
CKBOOL selectable = FALSE;
stringListArray->GetElementValue(select, CGBLWidget::eStringListArrayColumnSelectable, &selectable);
if (selectable || (select < 0) || (select >= stringListArray->GetRowCount()) )
{
// Select only this row
for (int selRow = 0;selRow < stringListArray->GetRowCount();selRow++)
{
CKBOOL bSelect = (selRow == select);
stringListArray->SetElementValue(selRow, CGBLWidget::eStringListArrayColumnSelected, &bSelect);
}
// Set focus to this item too
if (selectable)
beh->SetLocalParameterValue(eLocalParamFocussedItem, &select);
// Update selected item p-out
beh->SetOutputParameterValue(eParamOutputSelectedItem, &select);
// Activate new selection b-out
beh->ActivateOutput(eBehOutputNewSelection);
// Do we need to scroll?
int scrollOffset;
beh->GetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
VxRect stringListRect = GetRectStringList(clientRect, fontHeight, columnsArray);
if (!CGBLWidget::GetListRowRect(stringListRect, select, scrollOffset, stringListArray->GetRowCount(),
fontHeight, NULL))
{
// Set the scroll offset to the focussed item
scrollOffset = select;
beh->SetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
}
}
}
}
// Check for Focus b-in
if (beh->IsInputActive(eBehInputFocus))
{
// Reset b-in
beh->ActivateInput(eBehInputFocus, FALSE);
// Set focus
int nFocus = 0;
beh->GetInputParameterValue(eParamInputFocusItem, &nFocus);
// Copy to focus item and scroll offset
beh->SetLocalParameterValue(eLocalParamFocussedItem, &nFocus);
// Do we need to scroll?
int scrollOffset;
beh->GetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
VxRect stringListRect = GetRectStringList(clientRect, fontHeight, columnsArray);
if (!CGBLWidget::GetListRowRect(stringListRect, nFocus, scrollOffset, stringListArray->GetRowCount(),
fontHeight, NULL))
{
// Set the scroll offset to the focussed item
scrollOffset = nFocus;
beh->SetLocalParameterValue(eLocalParamScrollOffset, &scrollOffset);
}
}
// Only handle mouse clicks and keyboard input when enabled
if (CGBLWidget::IsWidgetEnabled(beh))
{
// Handle the clicking of the scroll buttons
HandleScrollButtonClicks(beh, inputManager, ent, clientRect, fontHeight, behContext.DeltaTime);
// Get the string list area
VxRect stringListRect = GetRectStringList(clientRect, fontHeight, columnsArray);
if (isFocussed)
{
// Handle the pressing of the arrow keys
HandleArrowKeyPresses(beh, inputManager, behContext.DeltaTime, stringListRect, fontHeight, stringListArray);
// Handle the pressing of the space bar to select
HandleSpaceBarPress(beh, inputManager, stringListArray);
}
// Handle clicking on the rows
HandleListItemClicks(beh, inputManager, ent, stringListRect, stringListArray, fontHeight);
}
return behReturn;
}
/*
*******************************************************************
* Function: int BehaviourFunction( const CKBehaviorContext& behaviorContext )
*
* Description : The execution function is the function that will be called
* during the process loop of the behavior engine, if the behavior
* is defined as using an execution function. This function is not
* called if the behavior is defined as a graph. This function is the
* heart of the behavior: it should compute the essence of the behavior,
* in an incremental way. The minimum amount of computing should be
* done at each call, to leave time for the other behaviors to run.
* The function receives the delay in milliseconds that has elapsed
* since the last behavioral process, and should rely on this value to
* manage the amount of effect it has on its computation, if the effect
* of this computation relies on time.
*
* Parameters :
* behaviourContext r Behavior context reference, which gives access to
* frequently used global objects ( context, level, manager, etc... )
*
* Returns : int, If it is done, it should return CKBR_OK. If it returns
* CKBR_ACTIVATENEXTFRAME, the behavior will again be called
* during the next process loop.
*
*******************************************************************
*/
int GBLCIGetCIS_IDList(const CKBehaviorContext& behcontext)
{
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// Retrieving min data :
CKBehavior* beh = behcontext.Behavior;
CKContext* ctx = behcontext.Context;
beh->ActivateInput(0,false);
// required managers
CGBLCIConfigurationController* cman=static_cast<CGBLCIConfigurationController*>(ctx->GetManagerByGuid(CONFIGURATION_MAN_GUID));
IGBLCIManageInterface *cisFac = cman->GetCISFactoryInterface();
CGBLSMStorageManager *storageManager = static_cast<CGBLSMStorageManager *>(ctx->GetManagerByGuid(GBLSMStorageManagerGUID));
IGBLSMConfigurationAccess* smCIS = storageManager->GetConfigurationInterface();
//get LAID from bb :
CKParameter *parameterINGetLAID = beh->GetInputParameter(BEH_IN_INDEX_LAID)->GetRealSource();
using namespace GBLCommon::ParameterTools;
//contruct c rep of the LAID :
CGBLLAID laID(
GetValueFromParameterStruct<int>(parameterINGetLAID,0,false),
GetValueFromParameterStruct<int>(parameterINGetLAID,1,false)
);
// get inout array :
CKDataArray * resultArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(BEH_IN_INDEX_TARGETARRAY));
if(resultArray == NULL)
{
beh->ActivateOutput(1, true);
CKParameterOut *pOut = beh->GetOutputParameter(0);
CGBLCOError::EGBLCOErrorType tType;
tType= CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL;
TGBLError::SetTGBLError(pOut, tType , 19021, "Missing or incorrect parameter provided");
return CKBR_OK;
}
//get error parameter
CKParameterOut *parameterOutError = beh->GetOutputParameter(BEH_OUT_INDEX_ERROR);
// get cis list
CGBLCOError returnValue = smCIS->RetrieveCISIDList(laID,resultArray);
// check results and output error
if (returnValue == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
{
TGBLError::SetTGBLError(parameterOutError,returnValue.GetType(),returnValue.GetCode(),(CKSTRING)returnValue.GetDescription());
beh->ActivateOutput(BEH_PIN_OUT_INDEX_SUCCESS, true);
}
else
{
CGBLCOError::EGBLCOErrorType tType = CGBLCOError::EGBLCOErrorType::GBLCO_OK;
switch((CGBLCOError::EGBLCOErrorType)returnValue)
{
case 0:
tType = CGBLCOError::EGBLCOErrorType::GBLCO_OK;
break;
case 1:
tType = CGBLCOError::EGBLCOErrorType::GBLCO_FATAL;
break;
case 2:
tType = CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL;
break;
case 3:
tType = CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL;
break;
}
TGBLError::SetTGBLError(parameterOutError,tType,returnValue.GetCode(),(CKSTRING)returnValue.GetDescription());
beh->ActivateOutput(BEH_PIN_OUT_INDEX_ERROR, true);
}
return CKBR_OK;
}
/*
*******************************************************************
* Function: int BehaviourFunction()
*
* Description : Returns the number of plugins in this DLL
*
* Paramters :
* CKBehaviorContext& r The virtools behaviour context
*
* Returns : One of the many virtools return values
*
*******************************************************************
*/
int CGBLFileSystem::BehaviourFunction(const CKBehaviorContext& behContext)
{
BOOL error = FALSE;
// Quick bit of error checking
CKBehavior* beh = behContext.Behavior;
CKBeObject* beObject = beh->GetTarget();
int fileSystemBrowseMode = 0;
if (!beObject)
{
error = TRUE;
}
if (!error)
{
// Reset On input, if active
if (beh->IsInputActive(eBehInputOn))
{
beh->ActivateInput(eBehInputOn, FALSE);
// Clear error message output
beh->SetOutputParameterValue(eParamOutputErrorMsg, EMPTY_STRING);
}
// see which mode we are in
beh->GetInputParameterValue(eParamInputMode, &fileSystemBrowseMode);
}
if (!error)
{
// See if we have the special case
char *currentFolder = NULL;
currentFolder = (char*)(beh->GetInputParameterReadDataPtr(eParamInputCurrentFolder));
XString scannedFolder = currentFolder;
if (currentFolder)
{
// special case takes priority over FILES / FOLDER mode
if (strcmp(currentFolder,SPECIAL_CASE)==0)
{
beh->SetOutputParameterValue(eParamOutputScannedFolder, scannedFolder.CStr(),scannedFolder.Length()+1 );
if (fileSystemBrowseMode == eFolder)
{
if (GetLogicalDrives(beh))
{
// Everythings gone ok we have a list of the logical drives
beh->ActivateOutput(eBehOutputDone, TRUE);
}
else
{
// Something went wrong
beh->SetOutputParameterValue(eParamOutputErrorMsg, "Failed To Scan The Logical Drives");
beh->ActivateOutput(eBehOutputError, TRUE);
}
}
else
{
// Cant scan for files in the SPECIAL_CASE
// Get the destination data array and clear it out
CKDataArray* dataArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputDataArray));
if (!dataArray)
{
CGBLWidget::OutputBBErrorMsg(beh, "Please attatch an array to the BB");
}
else
{
dataArray->Clear();
dataArray->AddRow();
int currentRow = dataArray->GetRowCount()-1; // 0 index
dataArray->SetElementStringValue(currentRow,NAME_COLUMN,NOT_FOUND);
beh->ActivateOutput(eBehOutputDone, TRUE);
}
}
}
else
{
// add a "\" to the end, it makes the ouput consistent.
int len = strlen (scannedFolder.CStr());
if ((scannedFolder[len-1])!=SINGLE_SEPERATOR)
{
scannedFolder << SINGLE_SEPERATOR;
}
// Try to scan the passed folder
if (GetData(beh,fileSystemBrowseMode)==FALSE)
{
// Error Handling we can handle errors here
// We most likely got here because the user doesnt have access to the folder.
if (fileSystemBrowseMode == eFile)
{
beh->SetOutputParameterValue(eParamOutputErrorMsg, "Failed To Scan Files");
}
else
{
beh->SetOutputParameterValue(eParamOutputErrorMsg, "Failed To Scan Folders");
}
beh->ActivateOutput(eBehOutputDone, TRUE);
// Handleable, recoverable errors, so dont set the error flag
//beh->ActivateOutput(eBehOutputError, TRUE);
}
else
{
// No errors
beh->SetOutputParameterValue(eParamOutputScannedFolder, scannedFolder.CStr(), scannedFolder.Length() + 1);
beh->ActivateOutput(eBehOutputDone, TRUE);
}
}
}
else
{
// Dont think we can ever get here becuase "" is a valid folder.
// Just in case though.
beh->SetOutputParameterValue(eParamOutputErrorMsg, "Please Supply a Folder To Scan");
beh->ActivateOutput(eBehOutputError, TRUE);
}
}
return CKBR_OK;
}
int DOOwnerChanged(const CKBehaviorContext& behcontext)
{
CKBehavior* beh = behcontext.Behavior;
CKMessageManager* mm = behcontext.MessageManager;
CKContext* ctx = behcontext.Context;
//////////////////////////////////////////////////////////////////////////
//connection id :
int connectionID = vtTools::BehaviorTools::GetInputParameterValue<int>(beh,0);
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
if (beh->IsInputActive(0))
{
beh->ActivateOutput(0);
beh->ActivateInput(0,FALSE);
}
if (beh->IsInputActive(1))
{
beh->ActivateOutput(1);
beh->ActivateInput(1,FALSE);
return 0;
}
//////////////////////////////////////////////////////////////////////////
//the object :
CK3dEntity *obj= (CK3dEntity*)beh->GetInputParameterObject(1);
if (!obj)
{
beh->ActivateOutput(4);
return CKBR_ACTIVATENEXTFRAME;
}
//////////////////////////////////////////////////////////////////////////
//network ok ?
xNetInterface *cin = GetNM()->GetClientNetInterface();
if (!cin)
{
CKParameterOut *pout = beh->GetOutputParameter(1);
XString errorMesg("distributed object creation failed,no network connection !");
pout->SetStringValue(errorMesg.Str());
beh->ActivateOutput(4);
return CKBR_ACTIVATENEXTFRAME;
}
IDistributedObjects*doInterface = cin->getDistObjectInterface();
//////////////////////////////////////////////////////////////////////////
//we come in by input 0 :
xDistributedObject *dobj = doInterface->getByEntityID(obj->GetID());
if (!dobj)
{
CKParameterOut *pout = beh->GetOutputParameter(1);
XString errorMesg("There is no such an object");
pout->SetStringValue(errorMesg.Str());
beh->ActivateOutput(4);
} else
{
if (dobj->getOwnershipState().test(1 << E_DO_OS_RELEASED) && dobj->getOwnershipState().test( 1 << E_DO_OS_OWNERCHANGED) )
{
beh->ActivateOutput(3);
}
if (dobj->getOwnershipState().testStrict(1 << E_DO_OS_OWNERCHANGED))
{
dobj->getOwnershipState().set( 1<<E_DO_OS_OWNERCHANGED ,false );
int newCLientID = dobj->getUserID();
beh->SetOutputParameterValue(0,&newCLientID);
beh->ActivateOutput(2);
}
}
return CKBR_ACTIVATENEXTFRAME;
}
