C++ CKBehavior::GetCKContext方法代码示例

CKERROR PMaterialIteratorCB(const CKBehaviorContext& behcontext)
{
	CKBehavior *beh = behcontext.Behavior;
	CKContext *ctx = beh->GetCKContext();

	switch(behcontext.CallbackMessage) 
	{

		case CKM_BEHAVIORLOAD:
		case CKM_BEHAVIORATTACH:
		{

			break;

		}

		case CKM_BEHAVIORSETTINGSEDITED:
		{


		
			
		}
		
	}
	return CKBR_OK;

}

CKERROR CallPythonFuncCB2(const CKBehaviorContext& behcontext)
{
	/************************************************************************/
	/*  collecting data :													*/
	/*  																	*/
	CKBehavior *beh = behcontext.Behavior;
	CKContext* ctx = beh->GetCKContext();
	CKParameterManager *pm = static_cast<CKParameterManager*>(ctx->GetParameterManager());
	/************************************************************************/
	/*	process virtools callbacks		:																			*/
	/*  																														*/

	switch(behcontext.CallbackMessage)
		{


		case CKM_BEHAVIOREDITED:
		case CKM_BEHAVIORSETTINGSEDITED:
		{

			assert(beh && ctx);
			
			int p_count  =  beh->GetOutputParameterCount();

			/*while(   (BEH_OUT_MIN_COUNT )   < p_count )
			{ 
				CKDestroyObject( beh->RemoveOutputParameter( --p_count) );
			}*/
			
			XString name("PyFuncX: ");
			name << ((CKSTRING) beh->GetInputParameterReadDataPtr(1));
			if ( strlen(((CKSTRING) beh->GetInputParameterReadDataPtr(1))) ==0)
			{
				XString name("PyFileX: ");
				name << ((CKSTRING) beh->GetInputParameterReadDataPtr(0));
				beh->SetName(name.Str());
				break;
			}
			beh->SetName(name.Str());
			break;
		}
		case CKM_BEHAVIORATTACH:
		case CKM_BEHAVIORLOAD : 
		{
			XString name("PyFuncX: ");
			name << ((CKSTRING) beh->GetInputParameterReadDataPtr(1));
			beh->SetName(name.Str());
			if ( strlen(((CKSTRING) beh->GetInputParameterReadDataPtr(1))) ==0)
			{
				XString name("PyFileX: ");
				name << ((CKSTRING) beh->GetInputParameterReadDataPtr(0));
				beh->SetName(name.Str());
				break;
			}
		}
	}
	return CKBR_OK;
}

/*
*******************************************************************
* Function: int RetrieveCICB( const CKBehaviorContext& behaviorContext )
*
* Description : The Behavior Callback function is called by Virtools when various events happen 
*               in the life of a BuildingBlock. Exactly which events trigger a call to the 
*               Behavior Callback function is defined in the Behavior Prototype, along with the 
*               declaration of the function pointer 
*
* Parameters :
*    behaviourContext    r   Behavior context reference, which gives 
*                            access to frequently used global objects 
*                            ( context, level, manager, etc... )
*
* Returns : int, The return value of the callback function should be one of the CK_BEHAVIOR_RETURN values.
*
*******************************************************************
*/
CKERROR RetrieveCICB(const CKBehaviorContext& behcontext)
{
	/************************************************************************/
	/*  collecting data :													*/
	/*  																	*/
	CKBehavior *beh = behcontext.Behavior;
	CKContext* ctx = beh->GetCKContext();
	CKParameterManager *pm = static_cast<CKParameterManager*>(ctx->GetParameterManager());
	/************************************************************************/
	/*	process virtools callbacks		:																			*/
	/*  																														*/

	switch(behcontext.CallbackMessage)
	{
	
		
		case CKM_BEHAVIOREDITED:
		case CKM_BEHAVIORSETTINGSEDITED:
		{
	
			assert(beh && ctx);
			BOOL getAsString,outputAttriubtes = false;
			beh->GetLocalParameterValue(BEH_SETTINGS_GET_AS_STRING,&getAsString);
			beh->GetLocalParameterValue(BEH_SETTINGS_GET_CUSTOM_ATTRIBUTES,&outputAttriubtes);
	       

			//////////////////////////////////////////////////////////////////////////
			// get ci by string
			if(getAsString)
			{
				CKParameterOut* ciValue = beh->GetOutputParameter(0);
				ciValue->SetType(pm->ParameterGuidToType(CKPGUID_STRING));
			}
			
			if(outputAttriubtes)
			{
				beh->CreateOutputParameter("Default Value",CKPGUID_STRING);
                beh->CreateOutputParameter("Unique name",CKPGUID_STRING);                
				beh->CreateOutputParameter("Description",CKPGUID_STRING);
				beh->CreateOutputParameter("Runtime flags",CIPRTFLAGSGUID);
				beh->CreateOutputParameter("Type",CKPGUID_PARAMETERTYPE);

			}

			int p_count  =  beh->GetOutputParameterCount();

			while(   (outputAttriubtes ? BEH_OUT_MAX_COUNT : BEH_OUT_MIN_COUNT )   < p_count )
			{ 
				CKDestroyObject( beh->RemoveOutputParameter( --p_count) );
			}
		
			
			
		}
	}
	return CKBR_OK;
}

/*
*******************************************************************
* Function: int CISIteratorCB( const CKBehaviorContext& behaviorContext )
*
* Description : The Behavior Callback function is called by Virtools when various events happen 
*               in the life of a BuildingBlock. Exactly which events trigger a call to the 
*               Behavior Callback function is defined in the Behavior Prototype, along with the 
*               declaration of the function pointer 
*
* Parameters :
*    behaviourContext    r   Behavior context reference, which gives 
*                            access to frequently used global objects 
*                            ( context, level, manager, etc... )
*
* Returns : int, The return value of the callback function should be one of the CK_BEHAVIOR_RETURN values.
*
*******************************************************************
*/
CKERROR CISIteratorCB(const CKBehaviorContext& behcontext)
{
	/************************************************************************/
	/*  collecting data :													*/
	/*  																	*/
	CKBehavior *beh = behcontext.Behavior;
	CKContext* ctx = beh->GetCKContext();
	CKParameterManager *pm = static_cast<CKParameterManager*>(ctx->GetParameterManager());
	CGBLCIConfigurationController* cman=(CGBLCIConfigurationController*)ctx->GetManagerByGuid(CONFIGURATION_MAN_GUID);


	/************************************************************************/
	/*	process virtools callbacks		:									*/
	/*  																	*/

	switch(behcontext.CallbackMessage)
	{
	case CKM_BEHAVIORRESET:
		{
			CKDataArray *array = NULL;
			beh->SetLocalParameterValue(BEH_LOCAL_PAR_INDEX_CIID_LIST,&array);
			break;
		}
	case CKM_BEHAVIOREDITED:
	case CKM_BEHAVIORSETTINGSEDITED :
		{

			assert(beh && ctx);

			BOOL getFromDB = false;
			beh->GetLocalParameterValue(BEH_LOCAL_PAR_INDEX_DB_MODE,&getFromDB);

			if( getFromDB &&  ( beh->GetInputParameterCount() ==  BEH_IN_INDEX_MIN_COUNT ) )
			{
				beh->CreateInputParameter("CIS ID", CKPGUID_INT);
			}
			//////////////////////////////////////////////////////////////////////////
			//remove all pIns :
			int p_count  =  beh->GetInputParameterCount();

			while( (getFromDB ? BEH_IN_INDEX_MAX_COUNT : BEH_IN_INDEX_MIN_COUNT ) < p_count )
			{ 
				CKDestroyObject( beh->RemoveInputParameter( --p_count) );
			}

			break;

		}

	}
	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.
*
* 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);
//.........这里部分代码省略.........

/*
*******************************************************************
* Function: int GetCIValueCB( const CKBehaviorContext& behaviorContext )
*
* Description : The Behavior Callback function is called by Virtools when various events happen 
*               in the life of a BuildingBlock. Exactly which events trigger a call to the 
*               Behavior Callback function is defined in the Behavior Prototype, along with the 
*               declaration of the function pointer 
*
* Parameters :
*    behaviourContext    r   Behavior context reference, which gives 
*                            access to frequently used global objects 
*                            ( context, level, manager, etc... )
*
* Returns : int, The return value of the callback function should be one of the CK_BEHAVIOR_RETURN values.
*
*******************************************************************
*/
CKERROR GetCIValueCB(const CKBehaviorContext& behcontext)
{
	/************************************************************************/
	/*  collecting data :													*/
	/*  																	*/
	CKBehavior *beh = behcontext.Behavior;
	CKContext* ctx = beh->GetCKContext();
	CKParameterManager *pm = static_cast<CKParameterManager*>(ctx->GetParameterManager());
	/************************************************************************/
	/*	process virtools callbacks		:																			*/
	/*  																														*/

	switch(behcontext.CallbackMessage)
	{
	
		
		case CKM_BEHAVIOREDITED:
		case CKM_BEHAVIORSETTINGSEDITED:
		{
	
			assert(beh && ctx);
			BOOL getByName,getAsString,outputAttriubtes,outputOnChange = false;
			beh->GetLocalParameterValue(BEH_SETTINGS_GET_BY_NAME,&getByName);
			beh->GetLocalParameterValue(BEH_SETTINGS_GET_AS_STRING,&getAsString);
			beh->GetLocalParameterValue(BEH_SETTINGS_GET_CUSTOM_ATTRIBUTES,&outputAttriubtes);
			beh->GetLocalParameterValue(BEH_SETTINGS_OUTPUT_ON_CHANGE,&outputOnChange);


			//////////////////////////////////////////////////////////////////////////
			//we add beh - in - trigger, if we are in event mode:
			if (outputOnChange)
			{
				beh->AddInput("Stop");

				//change to correct name :
			 	CKBehaviorIO * out_trigger = beh->GetOutput(0);
				out_trigger->SetName("Change detected");
			}else
			{
				//change to correct name :
				CKBehaviorIO * out_trigger = beh->GetOutput(0);
				out_trigger->SetName("Finish");
			}
              

			//remove unecessary beh - input triggers from even-mode :  
			int count = beh->GetInputCount();

			while(  (outputOnChange ? BEH_IN_TRIGGER_MAX_COUNT  : BEH_IN_TRIGGER_MIN_COUNT )  <= count ) 
						beh->DeleteInput( count-- );

			CKParameterIn *ciIn = beh->GetInputParameter(0);
			if( getByName )
			{
				ciIn->SetType(pm->ParameterGuidToType(CKPGUID_STRING));
				ciIn->SetName("unique name of the configurable information");
			}else
			{
				ciIn->SetType(pm->ParameterGuidToType(CIPARAMETERGUID));
				ciIn->SetName("Configurable Information");
			}
			
			if(outputAttriubtes)
			{
				beh->CreateOutputParameter("Default Value",CKPGUID_STRING);
                beh->CreateOutputParameter("Unique name",CKPGUID_STRING);                
				beh->CreateOutputParameter("Description",CKPGUID_STRING);
				beh->CreateOutputParameter("Runtime flags",CIPRTFLAGSGUID);
				beh->CreateOutputParameter("Type",CKPGUID_PARAMETERTYPE);

			}

			int p_count  =  beh->GetOutputParameterCount();
			while(   (outputAttriubtes ? BEH_OUT_MAX_COUNT : BEH_OUT_MIN_COUNT )   < p_count )
			{ 
				CKDestroyObject( beh->RemoveOutputParameter( --p_count) );
			}
		
			
			
		}
	}
//.........这里部分代码省略.........