Example #1
0
void PhysicsComponent::sendTransformation(const btTransform& transformation, bool apply) {
#ifdef BT_USE_DOUBLE_PRECISION
	double m[16];
	transformation.getBasis().scaled(m_collisionShape->getLocalScaling()).getOpenGLSubMatrix(m);
	float x[16];
	x[0] = m[0]; x[1] = m[1]; x[2] = m[2]; x[3] = m[3];
	x[4] = m[4]; x[5] = m[5]; x[6] = m[6]; x[7] = m[7];
	x[8] = m[8]; x[9] = m[9]; x[10] = m[10]; x[11] = m[11];
	x[12] = transformation.getOrigin().x();
	x[13] = transformation.getOrigin().y();
	x[14] = transformation.getOrigin().z();
	x[15] = 1.0f;
#else
	float x[16];
	btMatrix3x3 scaledBasis = transformation.getBasis().scaled(m_collisionShape->getLocalScaling());
	btVector3 voffset = scaledBasis * btVector3(lX, lY, lZ);
	transformation.getBasis().scaled(m_collisionShape->getLocalScaling()).getOpenGLSubMatrix(x);

	x[12] = transformation.getOrigin().x();
	x[13] = transformation.getOrigin().y();
	x[14] = transformation.getOrigin().z();
	x[15] = 1.0f;
#endif
	// Merge scaling with scale free transformation
#ifdef DEBUG
	GameEvent proxy_event(GameEvent::E_SET_TRANSFORMATION, &GameEventData(x, 16), this);

	if (m_proxy) {
//		printf("PhysicsComponent::update: %.3f, %.3f, %.3f\n", x[12], x[13], x[14]);
//		printf("SENDING PROXY A TRANSFORMATION");
		if (m_proxy->checkEvent(&proxy_event))
			m_proxy->executeEvent(&proxy_event);

		//return;
	}
#endif

	x[12] = transformation.getOrigin().x() - voffset.x();
	x[13] = transformation.getOrigin().y() - voffset.y();
	x[14] = transformation.getOrigin().z() - voffset.z();

	GameEvent event(GameEvent::E_SET_TRANSFORMATION, &GameEventData(x, 16), this);

	if (m_owner->checkEvent(&event)) {
//		printf("PhysicsComponent::update: %.3f, %.3f, %.3f\n", x[12], x[13], x[14]);
		m_owner->executeEvent(&event);
		if (apply)
			setTransformation(x);
	} else {
		// Reset Physics State to original transformation
		GameEvent e(GameEvent::E_TRANSFORMATION, GameEventData((float*) x, 16), this);
		m_owner->executeEvent(&e);
		setTransformation(x);
		// deactivate object until it is reactivated again by another collision or physics adjustment
		m_rigidBody->setActivationState(WANTS_DEACTIVATION);
	}

}
void GUISoundManager::update(vector<string> eventCompList) {

	if (enabled) {
		if (fadeIN && fadeGain >= backgroundGain) {
			fadeIN = false;
			setBackgroundGain(backgroundGain);
		}

		if (fadeIN && play) {
			fadeGain += ( backgroundGain/GameEngine::FPS())/5.0f;


			if (backgroundSounds.size()>0) {
				for (unsigned int i = 0; i < backgroundSounds.size(); i++) {
					GameEvent eve(GameEvent::E_SET_SOUND_GAIN, &GameEventData(fadeGain), 0x0);
					GameEngine::sendEvent(backgroundSounds[i], &eve);
				}
			}
		}


		if (fadeOUT && fadeGain <= 0) {
			stopBackgroundMusic();
			fadeOUT = false;

			for (unsigned int i = 0; i < eventCompList.size(); i++) {
				GUIEventData::sendToComp(new GUIEventData(O_GUI_SOUND_FADEDOUT,L"GUISoundManager"),eventCompList.at(i).c_str());
			}
		}

		if (fadeOUT && play) {
			fadeGain -= ( backgroundGain/GameEngine::FPS())/2.0f;


			if (backgroundSounds.size()>0) {
				for (unsigned int i = 0; i < backgroundSounds.size(); i++) {
					GameEvent eve(GameEvent::E_SET_SOUND_GAIN, &GameEventData(fadeGain), 0x0);
					GameEngine::sendEvent(backgroundSounds[i], &eve);
				}
			}
		}


		if (backgroundSounds.size()>0) {
			bool playing = false;
			GameEvent isPlaying(GameEvent::E_GET_SOUND_ISPLAYING, &GameEventData(&playing), 0x0);
			GameEngine::sendEvent(backgroundSounds[backgroundTitle], &isPlaying);
			if (!playing && play)
				playNextBackgroundMusic();
		}

	}

}
Example #3
0
VideoComponent::VideoComponent(GameEntity* owner) : GameComponent(owner, "VideoComponent"), m_startTime(0), m_data(0x0), m_playing(false), 
	m_material(0), m_resize(false), m_bgraData(0x0), m_pgf(0x0), m_videoTexture(0), m_samplerIndex(-1), m_originalSampler(0), 
	m_autoStart(false), m_loop(false), m_startNextFrame(false), m_newData(false), m_hasAudio(false), m_camId(0)
{
	VideoManager::instance()->addComponent(this);
	// We need our own access to the com library for not disturbing others (like the SapiComponent)
	CoInitializeEx(NULL, COINIT_MULTITHREADED);

	// Listen to cam changes
	owner->addListener(GameEvent::E_ACTIVE_CAM_CHANGE, this);
	// And get the current one
	// First the GameEngine id
	int camID = 0;
	GameEvent camEvent(GameEvent::E_GET_ACTIVE_CAM, &GameEventData(&camID), this);
	GameModules::gameWorld()->executeEvent(&camEvent);
	// Then the entity
	GameEntity* camEntity = GameModules::gameWorld()->entity(camID);
	if (camEntity)
	{
		// And finally the horde id, puh!
		GameEvent getHordeID(GameEvent::E_GET_SCENEGRAPH_ID, &m_camId, this);
		camEntity->executeEvent(&getHordeID);
	}

	m_hdd = DrawDibOpen();
	m_hdc = CreateCompatibleDC(0);
}
Example #4
0
void VideoComponent::playAvi()
{
	if (m_playing)
	{
		// Already playing, so stop first to restart
		stopAvi();
		// And start the next frame (so the Sound Component will be able to stop the sound before)
		m_startNextFrame = true;
	}
	else if (m_pgf != 0x0 && m_material != 0 && m_videoTexture != 0 && m_samplerIndex != -1)
	{
		// And apply the new video texture as sampler to the material
		h3dSetResParamI(m_material, H3DMatRes::SamplerElem, m_samplerIndex, H3DMatRes::SampTexResI, m_videoTexture);

		m_startTime = GameEngine::currentTimeStamp();
		m_playing = true;

		if (m_hasAudio)
		{
			// Play the previously loaded sound
			GameEvent enableSound(GameEvent::E_SET_ENABLED, &GameEventData(true), this);
			m_owner->executeEvent(&enableSound);
		}
	}
}
Example #5
0
void SceneGraphComponent::traject()
{
	// apply trajections
	if (m_net_applyTrajection) {

		// apply translation
		m_transformation[12] += m_net_traject_translation.x * m_net_traject_speedup;
		m_transformation[13] += m_net_traject_translation.y * m_net_traject_speedup;
		m_transformation[14] += m_net_traject_translation.z * m_net_traject_speedup;

		// apply rotation
		Matrix4f trans( Matrix4f(m_transformation) * 
			Matrix4f(Quaternion(
				m_net_traject_rotation.x * m_net_traject_speedup,
				m_net_traject_rotation.y * m_net_traject_speedup,
				m_net_traject_rotation.z * m_net_traject_speedup
			)) );
		memcpy( m_transformation, trans.x, sizeof( float ) * 16 );

		// TODO: apply scale

		sendTransformation();

		GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(m_transformation, 16), this);
		m_owner->executeEvent(&event);
	}
}
Example #6
0
void SceneGraphComponent::setScale(const Vec3f *scale)
{
	/*Vec3f tr,rotation,sc;
	Matrix4f(m_transformation).decompose(tr,rotation,sc);	
	
	Matrix4f trans = Matrix4f::ScaleMat( scale->x, scale->y, scale->z );
	trans = trans * Matrix4f(Quaternion(rotation.x, rotation.y, rotation.z));
	trans.translate(m_transformation[12], m_transformation[13], m_transformation[14]);
	
	GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(trans.x, 16), 0);*/

	Vec3f tr,rotation,sc;
	Matrix4f(m_transformation).decompose(tr,rotation,sc);	
	
	Matrix4f trans = Matrix4f::ScaleMat( scale->x, scale->y, scale->z );
	trans = trans * Matrix4f(Quaternion(rotation.x, rotation.y, rotation.z));
	trans.translate(tr.x, tr.y, tr.z);
	
	GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(trans.x, 16), this);
	if (m_owner->checkEvent(&event))
	{
		// Apply the new transformation
		memcpy( m_transformation, trans.x, sizeof( float ) * 16 );
		// Send it to horde
		sendTransformation();
		//and to the other components
		m_owner->executeEvent(&event);
	}
}
Example #7
0
void SceneGraphComponent::translateGlobal(const Vec3f* translation)
{
	// ensure that m_transfomration is up to date
	checkTransformation();

	/*Matrix4f trans(m_transformation);
	trans.x[12] += translation->x;
	trans.x[13] += translation->y;
	trans.x[14] += translation->z;
	GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(trans.x, 16), 0);*/

	// Backup trans
	Vec3f transBackup(m_transformation[12], m_transformation[13], m_transformation[14]);

	m_transformation[12] += translation->x;
	m_transformation[13] += translation->y;
	m_transformation[14] += translation->z;
	
	GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(m_transformation, 16), this);
	if (m_owner->checkEvent(&event))
	{
		// Send transformation to horde
		sendTransformation();
		//and to the other components
		m_owner->executeEvent(&event);
	}
	else
	{
		// Revert changes
		m_transformation[12] = transBackup.x;
		m_transformation[13] = transBackup.y;
		m_transformation[14] = transBackup.z;
	}
}
void GUISoundManager::stopBackgroundMusic() {
	if (enabled&& backgroundSounds.size()>0) {
		for (unsigned int i = 0; i < backgroundSounds.size(); ++i)
		{
			bool playing = false;
			GameEvent isPlaying(GameEvent::E_GET_SOUND_ISPLAYING, &GameEventData(&playing), 0x0);
			GameEngine::sendEvent(backgroundSounds[i], &isPlaying);
			if (playing)
			{
				GameEvent eve(GameEvent::E_STOP_SOUND, &GameEventData(), 0x0);
				GameEngine::sendEvent(backgroundSounds[i], &eve);
			}
		}

		play = false;
	}
}
void GUISoundManager::setEventGain(float val) {
	if (eventSounds.size()>0) {
		eventGain = val;

		for (unsigned int i = 0; i < eventSounds.size(); i++) {
			GameEvent eve(GameEvent::E_SET_SOUND_GAIN, &GameEventData(val), 0x0);
			GameEngine::sendEvent(eventSounds[i]->getEntityID(), &eve);
		}
	}
}
void GUISoundManager::setBackgroundGain(float val) {
	if (backgroundSounds.size()>0) {
		backgroundGain = val;

		for (unsigned int i = 0; i < backgroundSounds.size(); i++)
		{
			GameEvent eve(GameEvent::E_SET_SOUND_GAIN, &GameEventData(val), 0x0);
			GameEngine::sendEvent(backgroundSounds[i], &eve);
		}
	}
}
void GUISoundManager::playBackgroundMusicWithFadeIn() {
	if (play == false && fadeIN == false) {
		fadeIN = true;
		fadeGain = 0;

		if (backgroundSounds.size()>0) {
			for (unsigned int i = 0; i < backgroundSounds.size(); i++) {
				GameEvent eve(GameEvent::E_SET_SOUND_GAIN, &GameEventData(0), 0x0);
				GameEngine::sendEvent(backgroundSounds[i], &eve);
			}
		}

		playBackgroundMusic();
	}
}
Example #12
0
void SceneGraphComponent::checkTransformation()
{
	// Check if transformation has been changed (e.g. by a transformation change of a parent node)
	if ( m_hordeID > 0 && h3dCheckNodeTransFlag( m_hordeID, true ) )
	{
		// Update the locally stored global transformation 
		const float* absTrans = 0;
		h3dGetNodeTransMats(m_hordeID, 0, &absTrans);
		memcpy(m_transformation, absTrans, sizeof(float) * 16);

		GameEvent event(GameEvent::E_SET_TRANSFORMATION, GameEventData(m_transformation, 16), this);
		m_owner->executeEvent(&event);
		m_visibilityFlag = 0;
	}
}
void GUISoundManager::playBackgroundMusic() {
	if (play == false) {
		if (enabled && backgroundTitle >= 0 && (unsigned)backgroundTitle<backgroundSounds.size()) {
			bool playing = false;
			GameEvent isPlaying(GameEvent::E_GET_SOUND_ISPLAYING, &GameEventData(&playing), 0x0);
			GameEngine::sendEvent(backgroundSounds[backgroundTitle], &isPlaying);
			if (!playing)
			{	
				GameEvent startSound(GameEvent::E_PLAY_SOUND, 0x0, 0x0);
				GameEngine::sendEvent(backgroundSounds[backgroundTitle], &startSound);
				play = true;
			}
		}
	}

}
Example #14
0
void VideoComponent::stopAvi()
{
	if (m_playing)
	{
		if (m_originalSampler != 0 && m_samplerIndex != -1 && m_material != 0)
			// Reset original sampler texture
			h3dSetResParamI(m_material, H3DMatRes::SamplerElem, m_samplerIndex, H3DMatRes::SampTexResI, m_originalSampler);

		if (m_hasAudio)
		{
			// Stopping a sound is done by setting the gain to 0
			GameEvent stopSound(GameEvent::E_SET_SOUND_GAIN, &GameEventData(0.0f), this);
			m_owner->executeEvent(&stopSound);
		}
		m_playing = false;
	}
}
Example #15
0
void VideoComponent::closeAvi()
{
	// Stop it first as it might still be playing
	stopAvi();

	// Unload the video if there is already one
	if (m_pgf)
	{
		delete[] m_bgraData;
		m_bgraData = 0x0;
		if (m_hBitmap)
			DeleteObject(m_hBitmap);					// Delete The Device Dependant Bitmap Object
		if (m_pgf)
			AVIStreamGetFrameClose(m_pgf);				// Deallocates The GetFrame Resources
		m_pgf = 0x0;
		if (m_pavi)
			AVIStreamRelease(m_pavi);					// Release The Stream
		AVIFileExit();								// Release The File
		if (m_videoTexture)
		{
			// Remove video texture
			h3dRemoveResource(m_videoTexture);
			// And release it if unused now (should be, else we can't create the same again)
			h3dReleaseUnusedResources();		
			m_videoTexture = 0;
			m_originalSampler = 0;
			m_samplerIndex = 0;
		}
		if (m_hasAudio)
		{
			// Set an empty sound for releasing the old one
			GameEvent clearSound(GameEvent::E_SET_SOUND_FILE, &GameEventData(""), this);
			m_owner->executeEvent(&clearSound);
			m_hasAudio = false;
		}
	}
}
Example #16
0
void PhysicsComponent::loadFromXml(const XMLNode* description) {
	GameLog::logMessage("LOADING BULLET FROM XML");
	// Delete old physics representation
	//release();

	Matrix4f objTrans;
	m_owner->executeEvent(&GameEvent(GameEvent::E_TRANSFORMATION, &GameEventData((float*) objTrans.x, 16), this));

	Vec3f t, r, s;
	objTrans.decompose(t, r, s);

	// Parse Physics Node Configuration
	float mass = static_cast<float>(atof(description->getAttribute("mass", "0.0")));

	const char* shape = description->getAttribute("shape", "Box");
	// create collision shape based on the node configuration
	if (shape && _stricmp(shape, "Box") == 0) // Bounding Box Shape
			{
		float dimX = static_cast<float>(atof(description->getAttribute("x", "1.0")));
		float dimY = static_cast<float>(atof(description->getAttribute("y", "1.0")));
		float dimZ = static_cast<float>(atof(description->getAttribute("z", "1.0")));
		// update box settings with node scaling (TODO is this necessary if we already set the scale by using setLocalScaling?)
		//m_collisionShape = new btBoxShape(btVector3(dimX * s.x, dimY * s.y, dimZ * s.z));
		m_collisionShape = new btBoxShape(btVector3(dimX, dimY, dimZ));
	} else if (shape && _stricmp(shape, "Sphere") == 0) // Sphere Shape
			{
		float radius = static_cast<float>(atof(description->getAttribute("radius", "1.0")));
		m_collisionShape = new btSphereShape(radius);
	} else if (shape && _stricmp(shape, "Cylinder") == 0) // Cylinder Shape
			{
		float radius0 = static_cast<float>(atof(description->getAttribute("radius", "1.0")));
		float height = static_cast<float>(atof(description->getAttribute("height", "1.0")));
		m_collisionShape = new btCylinderShape(btVector3(radius0, height, radius0));
	} else // Mesh Shape
	{
		MeshData meshData;
		GameEvent meshEvent(GameEvent::E_MESH_DATA, &meshData, this);
		// get mesh data from graphics engine
		m_owner->executeEvent(&meshEvent);

		if (meshData.VertexBase && (meshData.TriangleBase32 || meshData.TriangleBase16)) {
			// Create new mesh in physics engine
			m_btTriangleMesh = new btTriangleMesh();
			int offset = 3;
			if (meshData.TriangleMode == 5) // Triangle Strip
				offset = 1;

			// copy mesh from graphics to physics
			bool index16 = false;
			if (meshData.TriangleBase16)
				index16 = true;
			for (unsigned int i = 0; i < meshData.NumTriangleIndices - 2; i += offset) {
				unsigned int index1 = index16 ? (meshData.TriangleBase16[i] - meshData.VertRStart) * 3 : (meshData.TriangleBase32[i] - meshData.VertRStart) * 3;
				unsigned int index2 = index16 ? (meshData.TriangleBase16[i + 1] - meshData.VertRStart) * 3 : (meshData.TriangleBase32[i + 1] - meshData.VertRStart) * 3;
				unsigned int index3 = index16 ? (meshData.TriangleBase16[i + 2] - meshData.VertRStart) * 3 : (meshData.TriangleBase32[i + 2] - meshData.VertRStart) * 3;
				m_btTriangleMesh->addTriangle(btVector3(meshData.VertexBase[index1], meshData.VertexBase[index1 + 1], meshData.VertexBase[index1 + 2]),
						btVector3(meshData.VertexBase[index2], meshData.VertexBase[index2 + 1], meshData.VertexBase[index2 + 2]),
						btVector3(meshData.VertexBase[index3], meshData.VertexBase[index3 + 1], meshData.VertexBase[index3 + 2]));
			}

			bool useQuantizedAabbCompression = true;

			if (mass > 0) {
				//btGImpactMeshShape* shape = new btGImpactMeshShape(m_btTriangleMesh);

				btGImpactConvexDecompositionShape* shape = new btGImpactConvexDecompositionShape(m_btTriangleMesh, btVector3(1.f, 1.f, 1.f), btScalar(0.1f), true);

				shape->updateBound();

				//btCollisionDispatcher* dispatcher = static_cast<btCollisionDispatcher *>(Physics::instance()->dispatcher());
				//btGImpactCollisionAlgorithm::registerAlgorithm(dispatcher);

				m_collisionShape = shape;

				//m_collisionShape = new btConvexTriangleMeshShape(m_btTriangleMesh);
			} else
				// BvhTriangleMesh can be used only for static objects
				m_collisionShape = new btBvhTriangleMeshShape(m_btTriangleMesh, useQuantizedAabbCompression);
		} else {
			GameLog::errorMessage("The mesh data for the physics representation couldn't be retrieved");
			return;
		}
	}

	GameLog::logMessage("PARSED SHAPE FROM XML");

	bool kinematic = _stricmp(description->getAttribute("kinematic", "false"), "true") == 0 || _stricmp(description->getAttribute("kinematic", "0"), "1") == 0;

	bool nondynamic = _stricmp(description->getAttribute("static", "false"), "true") == 0 || _stricmp(description->getAttribute("static", "0"), "1") == 0;

	bool ragdoll = _stricmp(description->getAttribute("ragdoll", "false"), "true") == 0 || _stricmp(description->getAttribute("ragdoll", "0"), "1") == 0;
	// Create initial transformation without scale
	btTransform tr;
	tr.setIdentity();
	tr.setRotation(btQuaternion(r.x, r.y, r.z));

	btMatrix3x3 rot = tr.getBasis();

	XMLNode offsetXMLNode = description->getChildNode("Offset");

	if (!offsetXMLNode.isEmpty()) {
		lX = static_cast<float>(atof(offsetXMLNode.getAttribute("lX", "0.0")));
		lY = static_cast<float>(atof(offsetXMLNode.getAttribute("lY", "0.0")));
		lZ = static_cast<float>(atof(offsetXMLNode.getAttribute("lZ", "0.0")));
	}

	btVector3 offset = btVector3(lX * s.x, lY * s.y, lZ * s.z);

	tr.setOrigin(btVector3(t.x, t.y, t.z) + rot * offset);
	// Set local scaling in collision shape because Bullet does not support scaling in the world transformation matrices
	m_collisionShape->setLocalScaling(btVector3(s.x, s.y, s.z));
	btVector3 localInertia(0, 0, 0);
	//rigidbody is dynamic if and only if mass is non zero otherwise static
	if (mass != 0)
		m_collisionShape->calculateLocalInertia(mass, localInertia);
	if (mass != 0 || kinematic)
		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
		m_motionState = new btDefaultMotionState(tr);

	btRigidBody::btRigidBodyConstructionInfo rbInfo(mass, m_motionState, m_collisionShape, localInertia);
	rbInfo.m_startWorldTransform = tr;
	//rbInfo.m_restitution = btScalar( atof(description->getAttribute("restitution", "0")) );
	//rbInfo.m_friction = btScalar( atof(description->getAttribute("static_friction", "0.5")) );
	// Threshold for deactivation of objects (if movement is below this value the object gets deactivated)
	//rbInfo.m_angularSleepingThreshold = 0.8f;
	//rbInfo.m_linearSleepingThreshold = 0.8f;

	m_rigidBody = new btRigidBody(rbInfo);
	m_rigidBody->setUserPointer(this);
	m_rigidBody->setDeactivationTime(2.0f);

	// Add support for collision detection if mass is zero but kinematic is explicitly enabled
	if (kinematic && mass == 0 && !nondynamic) {
		m_rigidBody->setCollisionFlags(m_rigidBody->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
		m_rigidBody->setActivationState(DISABLE_DEACTIVATION);
	}
	if (nondynamic && mass == 0) {
		m_rigidBody->setCollisionFlags(m_rigidBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT);
	}

	bool isTrigger = _stricmp(description->getAttribute("solid", "true"), "false") == 0 || _stricmp(description->getAttribute("solid", "1"), "0") == 0;
	if (isTrigger) {
		setCollisionResponse(true);
	}

	GameLog::logMessage("I'm a new Physics body: %s my Motion state: %d", m_owner->id().c_str(), m_motionState);
	printf("I'm a new Physics body: %s my Motion state: %d\n", m_owner->id().c_str(), m_motionState);

	if(!ragdoll) Physics::instance()->addObject(this);

	/*Geometry Proxy*/
	XMLNode proxyXMLNode = description->getChildNode("Proxy");
	if (proxyXMLNode.isEmpty())
		return;

	m_proxy = GameModules::gameWorld()->entity(proxyXMLNode.getAttribute("name", ""));

	if (m_proxy) {
		m_proxy->addListener(GameEvent::E_SET_TRANSFORMATION, this);
		m_proxy->addListener(GameEvent::E_SET_TRANSLATION, this);
		m_proxy->addListener(GameEvent::E_SET_ROTATION, this);
		m_proxy->addListener(GameEvent::E_TRANSLATE_LOCAL, this);
		m_proxy->addListener(GameEvent::E_TRANSLATE_GLOBAL, this);
		m_proxy->addListener(GameEvent::E_ROTATE_LOCAL, this);
	} else
		printf("No PROXY FOUND with EntityID: %s\n", proxyXMLNode.getAttribute("name", ""));

	/*Adding constraints*/

	XMLNode constraintXMLNode = description->getChildNode("Constraint");
	if (constraintXMLNode.isEmpty())
		return;

	const char* constraintType = constraintXMLNode.getAttribute("type", "Hinge");
	const char* parentName = constraintXMLNode.getAttribute("parent", "");
	PhysicsComponent* parent = getParent(parentName);

	if (!parent) {
		printf("NO PARENT FOUND\n");
		return;
	}

	XMLNode transformXMLNode = constraintXMLNode.getChildNode("TransformA");
	float qX = static_cast<float>(atof(transformXMLNode.getAttribute("qx", "1.0")));
	float qY = static_cast<float>(atof(transformXMLNode.getAttribute("qy", "1.0")));
	float qZ = static_cast<float>(atof(transformXMLNode.getAttribute("qz", "1.0")));
	float qW = static_cast<float>(atof(transformXMLNode.getAttribute("qw", "1.0")));
	float vX = static_cast<float>(atof(transformXMLNode.getAttribute("vx", "1.0")));
	float vY = static_cast<float>(atof(transformXMLNode.getAttribute("vy", "1.0")));
	float vZ = static_cast<float>(atof(transformXMLNode.getAttribute("vz", "1.0")));
	btTransform transformA;
	transformA.setIdentity();
	printf("%f \t %f \t %f  \n ", qX, qY, qZ);
	transformA.getBasis().setEulerZYX(qZ, qY, qX);
//	transformA.getBasis().setEulerZYX(M_PI_2,0,0);
	transformA.setOrigin(btVector3(vX * s.x, vY * s.y, vZ * s.z));
//	printf("%f \t %f \t %f \t %s \n ", vX*s.x, vY*s.y, vZ*s.z, m_owner ? m_owner->id().c_str() : "no name");
//	btTransform transformA = btTransform(btQuaternion(qX, qY, qZ, qW), btVector3(vX*s.x, vY*s.y, vZ*s.z));

	transformXMLNode = constraintXMLNode.getChildNode("TransformB");
	qX = static_cast<float>(atof(transformXMLNode.getAttribute("qx", "1.0")));
	qY = static_cast<float>(atof(transformXMLNode.getAttribute("qy", "1.0")));
	qZ = static_cast<float>(atof(transformXMLNode.getAttribute("qz", "1.0")));
	qW = static_cast<float>(atof(transformXMLNode.getAttribute("qw", "1.0")));
	vX = static_cast<float>(atof(transformXMLNode.getAttribute("vx", "1.0")));
	vY = static_cast<float>(atof(transformXMLNode.getAttribute("vy", "1.0")));
	vZ = static_cast<float>(atof(transformXMLNode.getAttribute("vz", "1.0")));
//	btTransform transformB = btTransform(btQuaternion(qX, qY, qZ, qW), btVector3(vX*s.x, vY*s.y, vZ*s.z));
	btTransform transformB;
	transformB.setIdentity();
	transformB.getBasis().setEulerZYX(qZ, qY, qX);
//	transformB.getBasis().setEulerZYX(M_PI_2,0,0);
	transformB.setOrigin(btVector3(vX * s.x, vY * s.y, vZ * s.z));

	XMLNode limitXMLNode = constraintXMLNode.getChildNode("Limit");

	if (_stricmp(constraintType, "Hinge") == 0) {
		btHingeConstraint* parentConstraint = new btHingeConstraint(*(parent->rigidBody()), *m_rigidBody, transformA, transformB);
		float low = static_cast<float>(atof(limitXMLNode.getAttribute("low", "0.0")));
		float high = static_cast<float>(atof(limitXMLNode.getAttribute("high", "0.75")));
		float softness = static_cast<float>(atof(limitXMLNode.getAttribute("softness", "0.9")));
		float biasFactor = static_cast<float>(atof(limitXMLNode.getAttribute("biasFactor", "0.3")));
		float relaxationFactor = static_cast<float>(atof(limitXMLNode.getAttribute("relaxationFactor", "1.0")));

		parentConstraint->setLimit(low, high, softness, biasFactor, relaxationFactor);
		m_parentConstraint = parentConstraint;
	} else if (_stricmp(constraintType, "ConeTwist") == 0) {
		btConeTwistConstraint* parentConstraint = new btConeTwistConstraint(*(parent->rigidBody()), *m_rigidBody, transformA, transformB);
		float swingSpan1 = static_cast<float>(atof(limitXMLNode.getAttribute("swingSpan1", "1.0")));
		float swingSpan2 = static_cast<float>(atof(limitXMLNode.getAttribute("swingSpan2", "1.0")));
		float twistSpan = static_cast<float>(atof(limitXMLNode.getAttribute("twistSpan", "1.0")));
		float softness = static_cast<float>(atof(limitXMLNode.getAttribute("softness", "0.9")));
		float biasFactor = static_cast<float>(atof(limitXMLNode.getAttribute("biasFactor", "0.3")));
		float relaxationFactor = static_cast<float>(atof(limitXMLNode.getAttribute("relaxationFactor", "1.0")));

		parentConstraint->setLimit(swingSpan1, swingSpan2, twistSpan, softness, biasFactor, relaxationFactor);
		m_parentConstraint = parentConstraint;
	}

	if(!ragdoll) Physics::instance()->addConstraint(m_parentConstraint);

}
Example #17
0
void PhonemeEditorWidget::save()
{
    blockSignals(true);
    //TODO: gaps between phonemes have to be interpreted as silence (phoneme "x")
    //Save changes to phoneme file
    if (!m_phonemeFileName.isEmpty() && m_saveButton->isEnabled())
    {
        QFile file( QDir(GameEngine::soundResourceDirectory()).absoluteFilePath(m_phonemeFileName) );
        if (file.open(QIODevice::WriteOnly | QIODevice::Truncate))
        {
            QTextStream stream(&file);
            m_phonemeXml.save(stream, 4);
            file.flush();
            file.close();
        }
        else
        {
            QMessageBox::warning(this, tr("Error"), tr("Error opening file %1 for writing:\n\n%2").arg(m_phonemeFileName).arg(file.errorString()));
            return;
        }
    }
    m_saveButton->setEnabled(false);
    GameEngine::sendEvent(m_entityWorldID, &GameEvent(GameEvent::E_SET_PHONEMES_FILE, &GameEventData(qPrintable(m_phonemeFileName)), 0));
    blockSignals(false);
}