//************************************ // Method: PClothDestroy // FullName: PClothDestroy // Access: public // Returns: int // Qualifier: // Parameter: const CKBehaviorContext& behcontext //************************************ int PClothDestroy(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; ////////////////////////////////////////////////////////////////////////// pCloth *cloth = GetPMan()->getCloth(target->GetID()); if (!cloth) { beh->ActivateOutput(0); return CKBR_PARAMETERERROR; } pWorld *world = cloth->getWorld(); world->destroyCloth(target->GetID()); beh->ActivateOutput(0); } return 0; }
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; }
/* ******************************************************************* * 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 CGBLBuildCommand::BehaviourFunction(const CKBehaviorContext& behaviorContext) { CKBehavior* behavior = behaviorContext.Behavior; CKContext* context = behaviorContext.Context; if( behavior->IsInputActive(EGBLBuildCommandBehInputs::BuildCommand) ) { DeactivateInputs(behaviorContext); DeactivateOutputs(behaviorContext); return DoBuildCommand (behaviorContext); } if( behavior->IsInputActive(EGBLBuildCommandBehInputs::CancelOperation)) { DeactivateInputs(behaviorContext); DeactivateOutputs(behaviorContext); ClearParameterOutputs (behaviorContext); int stateValue = EGBLBuildCommandState::Initial; behavior->SetLocalParameterValue (gblBuildCommandStateLocalPos, &stateValue); int initialParameterPosition = 0; behavior->SetLocalParameterValue (currentParameterPositionLocalPos, &initialParameterPosition); char *emptyString = ""; behavior->SetLocalParameterValue(commandStringLocalPos, emptyString, strlen(emptyString)+1); behavior->ActivateOutput (EGBLBuildCommandBehOutputs::Cancelled); } if( behavior->IsInputActive(EGBLBuildCommandBehInputs::ReadNextParameterValue)) { DeactivateInputs(behaviorContext); DeactivateOutputs(behaviorContext); int stateValue = 0; behavior->GetLocalParameterValue (gblBuildCommandStateLocalPos, &stateValue); if (! ( (stateValue == EGBLBuildCommandState::AwaitingParametersForUntargeted) || (stateValue == EGBLBuildCommandState::AwaitingParametersForNetwork) || (stateValue == EGBLBuildCommandState::GetTargets) ) ) { int stateValue = EGBLBuildCommandState::Initial; behavior->SetLocalParameterValue (gblBuildCommandStateLocalPos, &stateValue); int initialParameterPosition = 0; behavior->SetLocalParameterValue (currentParameterPositionLocalPos, &initialParameterPosition); char *emptyString = ""; behavior->SetLocalParameterValue(commandStringLocalPos, emptyString, strlen(emptyString)+1); CKParameterOut *parameterOutError = behavior->GetOutputParameter(EGBLBuildCommandParamOutputs::GetError); TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLFC_ERROR_BUILDCOMMAND_INVALID_STATE,GBLFC_ERROR_BUILDCOMMAND_INVALID_STATE_DESC); behavior->ActivateOutput (EGBLBuildCommandBehOutputs::Error); } return DoReadNextParameterValue (behaviorContext); } return CKBR_OK; }
/* ******************************************************************* * 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 CGBLLAESetLoadState::BehaviourFunction( const CKBehaviorContext& behaviorContext ) { CKBehavior* beh = behaviorContext.Behavior; CKContext* ctx = behaviorContext.Context; CGBLLAEManager *laeManager = (CGBLLAEManager *)ctx->GetManagerByGuid(GBLLAEManagerGUID); if (laeManager) { int state = 0; beh->GetInputParameterValue(0, &state); laeManager->SetLoadState(state); beh->ActivateInput(0, FALSE); beh->ActivateOutput(0); } else { beh->ActivateInput(0, FALSE); CKParameterOut *parameterOutError = beh->GetOutputParameter(0); TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLLAE_ERROR_CANTSETLAEIDENTITY,GBLLAE_ERROR_CANTSETLAEIDENTITY_DESC); beh->ActivateOutput(1); } return CKBR_OK; }
//************************************ // 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; }
//************************************ // Method: RegisterAttributeType // FullName: RegisterAttributeType // Access: public // Returns: int // Qualifier: // Parameter: const CKBehaviorContext& behcontext //************************************ int RegisterAttributeType(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; PhysicManager *pm = GetPMan(); CKAttributeManager* attman = ctx->GetAttributeManager(); CKParameterManager *pMan = ctx->GetParameterManager(); using namespace vtTools::BehaviorTools; if( beh->IsInputActive(0) ) { beh->ActivateInput(0,FALSE); CKSTRING name = GetInputParameterValue<CKSTRING>(beh,bbI_Name); CKSTRING category = GetInputParameterValue<CKSTRING>(beh,bbI_Category); CKSTRING defValue = GetInputParameterValue<CKSTRING>(beh,bbI_DefValue); int pType = GetInputParameterValue<int>(beh,bbI_PType); CK_CLASSID classId = GetInputParameterValue<CK_CLASSID>(beh,bbI_Class); int attFlags = 0 ; int user = GetInputParameterValue<int>(beh,bbI_User); int save = GetInputParameterValue<int>(beh,bbI_Save); if(user) attFlags|=CK_ATTRIBUT_USER; if(save) attFlags|=CK_ATTRIBUT_TOSAVE; attFlags|=CK_ATTRIBUT_CAN_DELETE; CKAttributeType aIType = attman->GetAttributeTypeByName(name); if (aIType!=-1) { beh->ActivateOutput(1); } int att = attman->RegisterNewAttributeType(name,pMan->ParameterTypeToGuid(pType),classId,(CK_ATTRIBUT_FLAGS)attFlags); if (strlen(category)) { attman->AddCategory(category); attman->SetAttributeCategory(att,category); } if (strlen(defValue)) { attman->SetAttributeDefaultValue(att,defValue); } } pm->populateAttributeFunctions(); pm->_RegisterAttributeCallbacks(); 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; }
int MidiEvent(const CKBehaviorContext& behcontext) { CKBehavior *beh = behcontext.Behavior; if( beh->IsInputActive(1) ){ // OFF beh->ActivateInput(1, FALSE); return CKBR_OK; } CKBOOL combiWasOK = FALSE; if( beh->IsInputActive(0) ){ // ON beh->ActivateInput(0, FALSE); beh->SetLocalParameterValue(0, &combiWasOK); } else { beh->GetLocalParameterValue(0, &combiWasOK); } MidiManager *mm = (MidiManager *) behcontext.Context->GetManagerByGuid( MIDI_MANAGER_GUID ); // Channel int channel=0; beh->GetInputParameterValue(0, &channel); int note, count = beh->GetInputParameterCount(); //--- test if all input notes are activated or not for( int a=1 ; a<count ; a++ ){ beh->GetInputParameterValue(a, ¬e); if( !mm->IsNoteActive(note, channel) ) break; } if( a==count ){ // All notes are pressed if( !combiWasOK ){ beh->ActivateOutput(0); combiWasOK = TRUE; beh->SetLocalParameterValue(0, &combiWasOK); return CKBR_ACTIVATENEXTFRAME; } } else { // Not all notes are pressed if( combiWasOK ){ beh->ActivateOutput(1); combiWasOK = FALSE; beh->SetLocalParameterValue(0, &combiWasOK); return CKBR_ACTIVATENEXTFRAME; } } return CKBR_ACTIVATENEXTFRAME; }
/* ******************************************************************* * Function: int GetCIS( 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 GetCIS(const CKBehaviorContext& behcontext) { ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Retrieving min data : CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; CGBLCIConfigurationController* cman=static_cast<CGBLCIConfigurationController*>(ctx->GetManagerByGuid(CONFIGURATION_MAN_GUID)); IGBLCIAccessInterface *accessInterface = cman->GetCISAccessInterface(); CGBLSMStorageManager *storageManager = static_cast<CGBLSMStorageManager *>(ctx->GetManagerByGuid(GBLSMStorageManagerGUID)); IGBLSMConfigurationAccess* smCIS = storageManager->GetConfigurationInterface(); CKParameterOut *parameterOutError = beh->GetOutputParameter(BEH_OUT_INDEX_ERROR); int idCIS = GBLCommon::BehaviorTools::GetInputParameterValue<int>(beh,BEH_IN_INDEX_CIS); CGBLCOError returnValue = accessInterface->GetCIS(idCIS); // 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; }
int DirToArray(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; XString filename((CKSTRING) beh->GetInputParameterReadDataPtr(0)); XString Mask((CKSTRING) beh->GetInputParameterReadDataPtr(1)); int rec; beh->GetInputParameterValue(2,&rec); if( beh->IsInputActive(0) ){ beh->ActivateInput(0,FALSE); flist.erase(flist.begin(),flist.end()); CKDirectoryParser MyParser(filename.Str(),Mask.Str(),rec); char* str = NULL; while(str = MyParser.GetNextFile()) flist.push_back(XString(str)); counter = 0; beh->ActivateInput(1,TRUE); } if( beh->IsInputActive(1) ){ beh->ActivateInput(1,FALSE); if ( counter < flist.size() ){ XString entry = flist.at(counter); CKParameterOut * pout = beh->GetOutputParameter(0); pout->SetStringValue(entry.Str() ); counter++; beh->SetOutputParameterValue(1,&counter); beh->ActivateOutput(1); }else{ beh->SetOutputParameterValue(1,&counter); counter = 0 ; beh->ActivateOutput(0); } } return 0; }
//************************************ // 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; }
//************************************ // Method: PBSetTriggerMask // FullName: PBSetTriggerMask // Access: public // Returns: int // Qualifier: // Parameter: const CKBehaviorContext& behcontext //************************************ int PBSetTriggerMask(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; ////////////////////////////////////////////////////////////////////////// // the world : pWorld *world = GetPMan()->getWorldByShapeReference(target); if (!world) { beh->ActivateOutput(0); return 0; } if (world) { NxShape *shape = world->getShapeByEntityID(target->GetID()); if (shape) { int onEnter = GetInputParameterValue<int>(beh,bbI_OnEnter); int onStay = GetInputParameterValue<int>(beh,bbI_OnStay); int onLeave = GetInputParameterValue<int>(beh,bbI_OnLeave); shape->setFlag(NX_TRIGGER_ON_ENTER,onEnter); shape->setFlag(NX_TRIGGER_ON_STAY,onStay); shape->setFlag(NX_TRIGGER_ON_LEAVE,onLeave); } } beh->ActivateOutput(0); } return 0; }
int FTPLogin(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; if( beh->IsInputActive(0)){ beh->ActivateInput(0,FALSE); HWND win = (HWND)ctx->GetMainWindow(); FtpInit(win); //HFILE hLogFile = _lcreat (LOG_FILE, 0); //FtpLogTo (hLogFile); FtpSetDefaultTimeOut (30); FtpSetPassiveMode(TRUE); FtpSetAsynchronousMode(); int Port; beh->GetInputParameterValue(3,&Port); XString Host((CKSTRING) beh->GetInputParameterReadDataPtr(0)); XString User((CKSTRING) beh->GetInputParameterReadDataPtr(1)); XString Pw((CKSTRING) beh->GetInputParameterReadDataPtr(2)); int Login = FtpLogin(Host.Str(),User.Str(),Pw.Str(),win,0); beh->SetOutputParameterValue(0,&Login); if (Login == 0)beh->ActivateOutput(0); else{ beh->ActivateOutput(2); return CKBR_OK; } return CKBR_ACTIVATENEXTFRAME; } if( beh->IsInputActive(1)){ beh->ActivateInput(1,FALSE); FtpCloseConnection(); FtpRelease (); beh->ActivateOutput(1); return CKBR_OK; } return CKBR_ACTIVATENEXTFRAME; }
int GetFile(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; int Length=0; // Start by In0 if( beh->IsInputActive(0)){ beh->ActivateInput(0,FALSE); XString RemoteFile((CKSTRING) beh->GetInputParameterReadDataPtr(0)); XString LocalFile((CKSTRING) beh->GetInputParameterReadDataPtr(1)); char *Type = "Type_B"; int Get = FtpRecvFile ( RemoteFile.Str(),LocalFile.Str(),*Type, FALSE,NULL,NULL); Length = FtpBytesToBeTransferred(); if ( Get !=0 ){ beh->SetOutputParameterValue(3,&Get); beh->ActivateOutput(2); return CKBR_OK; } beh->SetOutputParameterValue(0,&Length); beh->ActivateOutput(0); return CKBR_ACTIVATENEXTFRAME; } beh->GetOutputParameterValue(0,&Length); int down=FtpBytesTransferred(); beh->SetOutputParameterValue(1,&down); float progress=(float)(down*100.0f/Length); // percentage of file downloaded progress /=100.0f; beh->SetOutputParameterValue(2,&progress); if ( down == Length){ beh->ActivateOutput(1); return CKBR_OK; } return CKBR_ACTIVATENEXTFRAME; }
int GBLCOSetID::BehaviourFunction( const CKBehaviorContext& behContext ) { CKBehavior *behaviour = behContext.Behavior; CKContext *context = behContext.Context; behaviour->ActivateInput(ECGBLCOSetLAIDBehInputs::InSetIdentity, FALSE); CKAttributeManager*attributeManager = context->GetAttributeManager(); if (attributeManager != NULL) { CKLevel *level = context->GetCurrentLevel(); if ( level != NULL ) { int attributeType = attributeManager->GetAttributeTypeByName("GBLCOLAID"); if (attributeType == -1) attributeType = attributeManager->RegisterNewAttributeType("GBLCOLAID", GUID_TGBLLAID, CKCID_BEOBJECT); else if ( level->HasAttribute(attributeType) ) level->RemoveAttribute(attributeType); attributeManager->SetAttributeCategory(attributeType,"GBL"); level->SetAttribute(attributeType); CKParameter*attribute = level->GetAttributeParameter(attributeType); if ( attribute != NULL ) { CKParameterIn*pin = behaviour->GetInputParameter(ECGBLCOSetLAIDBehInputs::InSetIdentity); CKParameter*laid = pin->GetDirectSource(); if ( laid != NULL ) { CKERROR err = attribute->CopyValue(laid); if ( err == CK_OK ) { behaviour->ActivateOutput(ECGBLCOSetLAIDBehOutputs::OutIdentitySet, TRUE); behaviour->ActivateOutput(ECGBLCOSetLAIDBehOutputs::OutError, FALSE); return CKBR_OK; } } } } } CKParameterOut *parameterOutError = behaviour->GetOutputParameter(ECGBLCOSetLAIDParamOutputs::GetError); TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLCO_ERROR_SETID_ATTRIBUTE,GBLCO_ERROR_SETID_ATTRIBUTE_DESC); behaviour->ActivateOutput(ECGBLCOSetLAIDBehOutputs::OutIdentitySet, FALSE); behaviour->ActivateOutput(ECGBLCOSetLAIDBehOutputs::OutError, TRUE); return CKBR_GENERICERROR; }
int GetLastFileName(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; XString Inpath (ctx->GetLastCmoLoaded()); CKParameterOut *pout = beh->GetOutputParameter(0); pout->SetStringValue(Inpath.Str()); PathRemoveFileSpec(Inpath.Str()); CKParameterOut *pout2 = beh->GetOutputParameter(1); pout2->SetStringValue(Inpath.Str()); beh->ActivateOutput(0); return 0; }
int SetMousPos(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; if( beh->IsInputActive(0) ){ beh->ActivateInput(0,FALSE); DWORD data = 0; DWORD flags = MOUSEEVENTF_ABSOLUTE; // - Has the pointer moved since the last event? flags |= MOUSEEVENTF_MOVE; mouse_event(flags, 100,100, data, 0); beh->ActivateOutput(0); } return 0; }
int GetNextBBId(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; beh->ActivateInput(0,FALSE); int count = beh->GetParent()->GetSubBehaviorLinkCount(); int result = -1; for (int i=0; i<count; i++) { CKBehaviorLink *link = beh->GetParent()->GetSubBehaviorLink(i); if (link->GetInBehaviorIO() == beh->GetOutput(0)) { result = link->GetOutBehaviorIO()->GetOwner()->GetID(); beh->SetOutputParameterValue(0,&result); break; } } CKBehavior *script = static_cast<CKBehavior*>(ctx->GetObject(result)); if (script) { int bc = script->GetOutputCount(); int bc2 = script->GetInputCount(); } beh->ActivateOutput(0); beh->SetOutputParameterValue(0,&result); return CKBR_OK; }
int LoadCIS(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; GBLConfigurationManager* cman=(GBLConfigurationManager*)ctx->GetManagerByGuid(CONFIGURATION_MAN_GUID); using namespace Customisation::typedefs; using namespace GBLCommon::BehaviorTools; int LA = GetInputParameterValue<int>(beh,0); Customisation::typedefs::CIS* currentCIS = cman->GetCISAccessInterface()->GetCIS(LA); if( beh->IsInputActive(0) ){ beh->ActivateInput(0,FALSE); beh->ActivateOutput(0); beh->ActivateOutput(1); return CKBR_OK; } 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; }
/* ******************************************************************* * 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 GBLLDGetSetup::BehaviourFunction( const CKBehaviorContext& behaviorContext ) { CKBehavior *beh; CKContext *context; GBLLDManager *GBLLDMan; XString DBName; CKBOOL logging; XString ODBCName; XString proxyLogin; XString proxyPassword; XString serverAddress; XString serverLogin; XString serverPassword; CKBOOL serverMode; XString userName; int virtoolsUserID; CKBOOL webPlayerMode; int ConnectionID; if ( (beh = behaviorContext.Behavior) == NULL ) return CKBR_BEHAVIORERROR; if ( (context = behaviorContext.Context) == NULL ) return CKBR_BEHAVIORERROR; if ( (GBLLDMan = (GBLLDManager*)context->GetManagerByGuid(GBLLDManagerGUID)) == NULL ) return CKBR_BEHAVIORERROR; beh->ActivateInput( POS_I_IN, FALSE ); // Force the reading of the attributes GBLLDMan->ReadSetup(); ConnectionID = GBLLDMan->GetConnectionID(); DBName = GBLLDMan->GetDBName(); logging = GBLLDMan->IsLogging(); ODBCName = GBLLDMan->GetODBCName(); proxyLogin = GBLLDMan->GetProxyLogin(); proxyPassword = GBLLDMan->GetProxyPassword(); serverAddress = GBLLDMan->GetServerAddress(); serverLogin = GBLLDMan->GetServerLogin(); serverPassword = GBLLDMan->GetServerPassword(); serverMode = GBLLDMan->GetServerMode(); userName = GBLLDMan->GetUserName(); webPlayerMode = GBLLDMan->IsWebplayerMode(); virtoolsUserID = GBLLDMan->GetVirtoolsUserID(); beh->SetOutputParameterValue( POS_OP_CONNECTIONID, &ConnectionID ); beh->SetOutputParameterValue( POS_OP_DBNAME, DBName.CStr(), DBName.Length() ); beh->SetOutputParameterValue( POS_OP_LOGGING, &logging ); beh->SetOutputParameterValue( POS_OP_ODBCNAME, ODBCName.CStr(), ODBCName.Length() ); beh->SetOutputParameterValue( POS_OP_PROXYLOGIN, proxyLogin.CStr(), proxyLogin.Length() ); beh->SetOutputParameterValue( POS_OP_PROXYPASSWORD, proxyPassword.CStr(), proxyPassword.Length() ); beh->SetOutputParameterValue( POS_OP_SERVERADDRESS, serverAddress.CStr(), serverAddress.Length() ); beh->SetOutputParameterValue( POS_OP_SERVERLOGIN, serverLogin.CStr(), serverLogin.Length() ); beh->SetOutputParameterValue( POS_OP_SERVERMODE, &serverMode ); beh->SetOutputParameterValue( POS_OP_SERVERPASSWORD, serverPassword.CStr(), serverPassword.Length() ); beh->SetOutputParameterValue( POS_OP_USERNAME, userName.CStr(), userName.Length() ); beh->SetOutputParameterValue( POS_OP_WEBPLAYERMODE, &webPlayerMode ); beh->SetOutputParameterValue( POS_OP_VIRTOOLSUSERID, &virtoolsUserID ); beh->ActivateOutput( POS_O_OUT, TRUE ); return CKBR_OK; }
/* ******************************************************************* * Function: void CGBLBuildCommand::DeactivateOutputs(const CKBehaviorContext& behaviorContext) * * Description : Deactivates behavioral outputs for this building block * * Parameters : * behaviourContext r Behavior context reference, which gives * access to frequently used global objects * ( context, level, manager, etc... ) * ******************************************************************* */ void CGBLBuildCommand::DeactivateOutputs(const CKBehaviorContext& behaviorContext) { CKBehavior* behavior = behaviorContext.Behavior; for (int output = EGBLBuildCommandBehOutputs::Cancelled; output <= EGBLBuildCommandBehOutputs::Error; output++) { behavior->ActivateOutput (output, FALSE); } }
//************************************ // Method: PClothAttachVertexToPosition // FullName: PClothAttachVertexToPosition // Access: public // Returns: int // Qualifier: // Parameter: const CKBehaviorContext& behcontext //************************************ int PClothAttachVertexToPosition(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; ////////////////////////////////////////////////////////////////////////// pWorld *world = GetPMan()->getDefaultWorld(); if (!world) { beh->ActivateOutput(0); return CKBR_PARAMETERERROR; } pCloth *cloth = world->getCloth(target); if (!cloth) { beh->ActivateOutput(0); return CKBR_PARAMETERERROR; } int vertexIndex = GetInputParameterValue<int>(beh,bbI_VertexIndex); VxVector localPosition = GetInputParameterValue<VxVector>(beh,bbI_GlobalPosition); cloth->attachVertexToGlobalPosition(vertexIndex,localPosition); beh->ActivateOutput(0); } return 0; }
int SetCIConnectionDetails(const CKBehaviorContext& behcontext) { /************************************************************************/ /* collecting data : */ /* */ CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; GBLConfigurationManager* cman=(GBLConfigurationManager*)ctx->GetManagerByGuid(CONFIGURATION_MAN_GUID); CGBLSyncInterface *CINetworkInterface = cman->GetSynInterface(); /************************************************************************/ /* check interface : */ /* */ if (!CINetworkInterface->isValidInterface()) { //try to init the network interface : if (!CINetworkInterface->Init(ctx)) { return CKBR_BEHAVIORERROR; } } /************************************************************************/ /* process building block events : */ /* */ if( beh->IsInputActive(0) ) { beh->ActivateInput(0,FALSE); XString message((CKSTRING) beh->GetInputParameterReadDataPtr(0)); int connectionID = -1; beh->GetInputParameterValue(1,&CINetworkInterface->connectionID); CKAttributeManager *aMan = static_cast<CKAttributeManager*>(ctx->GetAttributeManager()); ////////////////////////////////////////////////////////////////////////// //store connection details in the scipt dummies attribute : CKAttributeType gblNetworkAtt = aMan->GetAttributeTypeByName( GBL_API_ENTRY("NetworkDetails")); if (!CINetworkInterface->messageDummy->HasAttribute(gblNetworkAtt) ) { CINetworkInterface->messageDummy->SetAttribute(gblNetworkAtt); } GBLCommon::ParameterTools::SetParameterStructureValue<int>(CINetworkInterface->messageDummy->GetAttributeParameter(gblNetworkAtt),0,CINetworkInterface->connectionID); GBLCommon::ParameterTools::SetParameterStructureValue<CKSTRING>(CINetworkInterface->messageDummy->GetAttributeParameter(gblNetworkAtt),1,CINetworkInterface->messageName.Str()); ////////////////////////////////////////////////////////////////////////// //activate and execute the script : behcontext.CurrentScene->Activate(CINetworkInterface->synchronizeScript,true); behcontext.CurrentScene->Activate(CINetworkInterface->messageDummy,FALSE); CINetworkInterface->synchronizeScript->Execute(1); beh->ActivateOutput(0); } return CKBR_OK; }
/* ******************************************************************* * 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 CGBLLAEGetLA::BehaviourFunction( const CKBehaviorContext& behaviorContext ) { CKBehavior* beh = behaviorContext.Behavior; CKContext* ctx = behaviorContext.Context; IGBLSMProfileAccess* pin = NULL; CGBLSMStorageManager *storageManager = (CGBLSMStorageManager *)ctx->GetManagerByGuid(GBLSMStorageManagerGUID); IGBLSMLAAccess *laInterface = storageManager->GetLAInterface(); char *arrayName = "laList"; CKDataArray* array; array = (CKDataArray *)ctx->GetObjectByNameAndClass(arrayName,CKCID_DATAARRAY,NULL); if ( !array ) { array = (CKDataArray *)ctx->CreateObject(CKCID_DATAARRAY,arrayName, CK_OBJECTCREATION_DYNAMIC); behaviorContext.CurrentLevel->AddObject( array ); array->InsertColumn( -1, CKARRAYTYPE_INT, "LAID" ); } else { array->Clear(); } CGBLCOError res = laInterface->RetrieveLAList(array); if ( res == CGBLCOError::EGBLCOErrorType::GBLCO_OK) { beh->ActivateInput(0, FALSE); beh->SetOutputParameterObject(0, array); beh->ActivateOutput(0); } else { beh->ActivateInput(0, FALSE); CKParameterOut *parameterOutError = beh->GetOutputParameter(1); TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLLAE_ERROR_GETLISTOFLAIDS,GBLLAE_ERROR_GETLISTOFLAIDS_DESC); beh->ActivateOutput(1); } return CKBR_OK; }
/* ******************************************************************* * 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 CGBLLAESetLAEData::BehaviourFunction( const CKBehaviorContext& behaviorContext ) { CKBehavior* beh = behaviorContext.Behavior; CKContext* ctx = behaviorContext.Context; IGBLSMProfileAccess* pin = NULL; CGBLSMStorageManager *storageManager = (CGBLSMStorageManager *)ctx->GetManagerByGuid(GBLSMStorageManagerGUID); IGBLSMLAEAccess *laeInterface = storageManager->GetLAEInterface(); int cisid; CGBLLAID laid; XString xlaid; XString laeName; int laeState = 0; CKDataArray *userIDList = NULL; CGBLLAEID laeid = 0; int dlaeid; beh->GetInputParameterValue(1, &dlaeid); laeid = dlaeid; GBLLAEDataType::GetGBLLAEData(beh->GetInputParameter(0)->GetRealSource(), cisid, laeName, laeState, xlaid, &userIDList ); laid.FromString(xlaid); CGBLCOError res = laeInterface->StoreLAE (laeState, cisid, laid, laeName, &laeid); if ( res == CGBLCOError::EGBLCOErrorType::GBLCO_OK) { beh->ActivateInput(0, FALSE); beh->ActivateOutput(0); } else { CKParameterOut *parameterOutError = beh->GetOutputParameter(0); TGBLError::SetTGBLError(parameterOutError,CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL,GBLLAE_ERROR_STORELAE,GBLLAE_ERROR_STORELAE_DESC); beh->ActivateOutput(1); } return CKBR_OK; }
int HasFFEffects(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; CKContext* ctx = behcontext.Context; HWND mWin = (HWND )ctx->GetMainWindow(); DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&g_pDI2, NULL ) ; // Get the first enumerated force feedback device g_pDI2->EnumDevices( 0, EnumFFDevicesCallback0, 0, DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK ); if( g_pFFDevice2 == NULL ) beh->ActivateOutput(1); else beh->ActivateOutput(0); FreeDirectInput0(); return CKBR_OK; }
/* ******************************************************************* * 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; }
//************************************ // Method: PClothAddForceAtVertex // FullName: PClothAddForceAtVertex // Access: public // Returns: int // Qualifier: // Parameter: const CKBehaviorContext& behcontext //************************************ int PClothAddForceAtVertex(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; ////////////////////////////////////////////////////////////////////////// pCloth *cloth = GetPMan()->getCloth(target->GetID()); if (!cloth) { beh->ActivateOutput(0); return CKBR_PARAMETERERROR; } int vertexIndex = GetInputParameterValue<int>(beh,bbI_VertexIndex); VxVector force = GetInputParameterValue<VxVector>(beh,bbI_Force); int forceMode = GetInputParameterValue<int>(beh,bbI_ForceMode); cloth->addForceAtVertex(force,vertexIndex,(ForceMode)forceMode); beh->ActivateOutput(0); } return 0; }
int GetCurrentCamera(const CKBehaviorContext& behcontext) { CKBehavior* beh = behcontext.Behavior; // Set IO states beh->ActivateInput(0,FALSE); beh->ActivateOutput(0); CKCamera* cam = behcontext.CurrentRenderContext->GetAttachedCamera(); beh->SetOutputParameterObject(0,cam); return CKBR_OK; }