コード例 #1
0
void ReplaceMaterialParam(const Palleon::MaterialPtr& material, const char* paramName, const CVector4& newParamValue)
{
	auto param = material->GetEffectParameter(paramName);
	CVector4 paramValue(0, 0, 0, 0);
	if(param.IsVector3())
	{
		paramValue = CVector4(param.GetVector3(), 0);
	}
	else
	{
		paramValue = param.GetVector4();
	}
	paramValue.x = (newParamValue.x == 1000.f) ? paramValue.x : newParamValue.x;
	paramValue.y = (newParamValue.y == 1000.f) ? paramValue.y : newParamValue.y;
	paramValue.z = (newParamValue.z == 1000.f) ? paramValue.z : newParamValue.z;
	paramValue.w = (newParamValue.w == 1000.f) ? paramValue.w : newParamValue.w;
	if(param.IsVector3())
	{
		param.SetVector3(paramValue.xyz());
	}
	else
	{
		param.SetVector4(paramValue);
	}
	material->SetEffectParameter(paramName, param);
}
コード例 #2
0
ファイル: grammar.c プロジェクト: steakknife/sblim-sfcc
static void methodRespContent(ParserControl *parm, parseUnion *stateUnion)
{
	parseUnion lvalp={0};
	ct = localLex(&lvalp, parm);
	if(ct == XTOK_ERROR) {
		dontLex = 1;
		error(parm, (parseUnion*)&lvalp.xtokErrorResp);
	}
	else if(ct == XTOK_RETVALUE || ct == XTOK_PARAMVALUE) {
		dontLex = 1;
		if(ct == XTOK_RETVALUE) {
			dontLex = 1;
			returnValue(parm, (parseUnion*)&lvalp.xtokReturnValue);
		}
		ct = localLex(&lvalp, parm);
		dontLex = 1;
		if(ct == XTOK_PARAMVALUE) {
			do {
				dontLex = 1;
				paramValue(parm, (parseUnion*)&lvalp.xtokParamValue);
				addParamValue(parm, &stateUnion->xtokMethodRespContent.values, &lvalp.xtokParamValue);
				ct = localLex(&lvalp, parm);
			}
			while(ct == XTOK_PARAMVALUE);
			dontLex = 1;
		}
	}
	else if(ct == ZTOK_METHODRESP) {
		dontLex = 1;
	}
	else {
		parseError("XTOK_ERROR or XTOK_RETVALUE or XTOK_PARAMVALUE or ZTOK_METHODRESP", ct, parm);
	}
}
コード例 #3
0
ファイル: multiagenttest.cpp プロジェクト: amininger/Soar
void MultiAgentTest::MyUpdateEventHandler( sml::smlUpdateEventId, void*, sml::Kernel* pKernel, sml::smlRunFlags )
{
	int agents = pKernel->GetNumberAgents() ;
	for (int agentIndex = 0 ; agentIndex < agents ; ++agentIndex)
	{
		sml::Agent* pAgent = pKernel->GetAgentByIndex( agentIndex ) ;
		CPPUNIT_ASSERT( pAgent != NULL );

		char const* pIOString = pAgent->ExecuteCommandLine( "print --depth 4 i1" ) ;
		CPPUNIT_ASSERT( pIOString != NULL );
		//std::cout << pIOString << std::endl ;

		// Make sure we can get the output link (had a bug where this wouldn't always work)
		sml::Identifier* pOutputLink = pAgent->GetOutputLink() ;
		CPPUNIT_ASSERT( pOutputLink != NULL );

		// Read in the commands
		int numberCommands = pAgent->GetNumberCommands() ;
		for ( int i = 0 ; i < numberCommands ; ++i )
		{
			sml::Identifier* pCommand = pAgent->GetCommand( i ) ;
			CPPUNIT_ASSERT( pCommand != NULL );

			char const* pName = pCommand->GetCommandName() ;
			CPPUNIT_ASSERT( pName != NULL );
			CPPUNIT_ASSERT( std::string( pName ) == "result" );

			// Receive the new total
			char const* pTotal = pCommand->GetParameterValue( "total" ) ;
			CPPUNIT_ASSERT( pTotal != NULL );
			std::stringstream paramValue( pTotal );
			int intTotal = 0;
			paramValue >> intTotal;

			// Mark command as completed in working memory
			pCommand->AddStatusComplete() ;

			// Place a new addition request on the input link
			UpdateInput( pAgent, intTotal );
		}
	}
}
コード例 #4
0
CLauncherWindow::StringKeyValueMap CLauncherWindow::GetUrlParameters(const TCHAR* url)
{
	std::map<std::tstring, std::tstring> parameters;
	auto paramStart = _tcschr(url, _T('?'));
	if(paramStart != nullptr)
	{
		while(1)
		{
			paramStart++;
			auto nextParam = _tcschr(paramStart, _T('&'));
			auto paramSeparatorPos = _tcschr(paramStart, _T('='));
			if(paramSeparatorPos != nullptr)
			{
				auto paramEnd = nextParam ? nextParam : (paramStart + _tcslen(paramStart));
				std::tstring paramName(paramStart, paramSeparatorPos);
				std::tstring paramValue(paramSeparatorPos + 1, paramEnd);
				parameters.insert(std::make_pair(paramName, paramValue));
			}
			if(nextParam == nullptr) break;
			paramStart = nextParam;
		}
	}
	return parameters;
}
コード例 #5
0
MyString
MultiLogFiles::getParamFromSubmitLine(MyString &submitLine,
		const char *paramName)
{
	MyString	paramValue("");

	const char *DELIM = "=";

	submitLine.Tokenize();
	const char *	rawToken = submitLine.GetNextToken(DELIM, true);
	if ( rawToken ) {
		MyString	token(rawToken);
		token.trim();
		if ( !strcasecmp(token.Value(), paramName) ) {
			rawToken = submitLine.GetNextToken(DELIM, true);
			if ( rawToken ) {
				paramValue = rawToken;
				paramValue.trim();
			}
		}
	}

	return paramValue;
}
コード例 #6
0
ファイル: synthv1_jack.cpp プロジェクト: eriser/synthv1
int synthv1_jack::process ( jack_nframes_t nframes )
{
	if (!m_activated)
		return 0;

	const uint16_t nchannels = synthv1::channels();
	float *ins[nchannels], *outs[nchannels];
	for (uint16_t k = 0; k < nchannels; ++k) {
		ins[k]  = static_cast<float *> (
			::jack_port_get_buffer(m_audio_ins[k], nframes));
		outs[k] = static_cast<float *> (
			::jack_port_get_buffer(m_audio_outs[k], nframes));
	}

	const float bpm_sync = paramValue(synthv1::DEL1_BPMSYNC);
	if (bpm_sync > 0.0f) {
		const float bpm_host = paramValue(synthv1::DEL1_BPMHOST);
		if (bpm_host > 0.0f) {
			jack_position_t pos;
			jack_transport_query(m_client, &pos);
			if (pos.valid & JackPositionBBT) {
				const float bpm = float(pos.beats_per_minute);
				if (::fabs(bpm_host - bpm) > 0.01f)
					setParamValue(synthv1::DEL1_BPMHOST, bpm);
			}
		}
	}

	uint32_t ndelta = 0;

#ifdef CONFIG_JACK_MIDI
	void *midi_in = ::jack_port_get_buffer(m_midi_in, nframes);
	if (midi_in) {
		const uint32_t nevents = ::jack_midi_get_event_count(midi_in);
		for (uint32_t n = 0; n < nevents; ++n) {
			jack_midi_event_t event;
			::jack_midi_event_get(&event, midi_in, n);
			uint32_t nread = event.time - ndelta;
			if (nread > 0) {
				synthv1::process(ins, outs, nread);
				for (uint16_t k = 0; k < nchannels; ++k) {
					ins[k]  += nread;
					outs[k] += nread;
				}
			}
			ndelta = event.time;
			synthv1::process_midi(event.buffer, event.size);
		}
	}
#endif
#ifdef CONFIG_ALSA_MIDI
	const jack_nframes_t buffer_size = ::jack_get_buffer_size(m_client);
	const jack_nframes_t frame_time  = ::jack_last_frame_time(m_client);
	uint8_t event_buffer[1024];
	jack_midi_event_t event;
	while (::jack_ringbuffer_peek(m_alsa_buffer,
			(char *) &event, sizeof(event)) == sizeof(event)) {
		if (event.time > frame_time)
			break;
		jack_nframes_t event_time = frame_time - event.time;
		if (event_time > buffer_size)
			event_time = 0;
		else
			event_time = buffer_size - event_time;
		if (event_time > ndelta) {
			const uint32_t nread = event_time - ndelta;
			if (nread > 0) {
				synthv1::process(ins, outs, nread);
				for (uint16_t k = 0; k < nchannels; ++k) {
					ins[k]  += nread;
					outs[k] += nread;
				}
			}
			ndelta = event_time;
		}
		::jack_ringbuffer_read_advance(m_alsa_buffer, sizeof(event));
		::jack_ringbuffer_read(m_alsa_buffer, (char *) event_buffer, event.size);
		synthv1::process_midi(event_buffer, event.size);
	}
#endif // CONFIG_ALSA_MIDI

	synthv1::process(ins, outs, nframes - ndelta);

	return 0;
}
コード例 #7
0
void QueryManager::addExpression(VARIABLETYPE variableType, string variableName) {
    ASTParameter param(variableName, variableType);
    ASTParameterValue paramValue(param);

    expressionValueList[variableName] = paramValue;
}