void kore::Camera::transformChanged(const TransformPtr& newTransform) {
  SceneNodeComponent::transformChanged(newTransform);

  _matView = glm::inverse(newTransform->getGlobal());
  _matViewInverse = newTransform->getGlobal();
  paramsChanged();
}

void CFlystickTranslationResetTool::OnTrackingButtonReleased(Quaternion q, Vec3f position){
	std::cout << "CFlystickTranslationResetTool::OnTrackingButtonReleased()" << std::endl;

	if (! m_bToolActive){
		std::cout << "tool is not active" << std::endl;
		return;
	}

	if (m_posgPickedObjectNode == NullFC){
		std::cout << "CFlystickTranslationResetTool: No object picked to reset translation" << std::endl;
		return;
	}

	NodePtr parentingTransformNode = GetParentTransformNode(m_posgPickedObjectNode);
	if (parentingTransformNode != NullFC){
		std::cout << "CFlystickTranslationResetTool: Resetting translation!" << std::endl;
		TransformPtr transform = TransformPtr::dcast(parentingTransformNode->getCore());
		Matrix m = transform->getMatrix();
		m.setTranslate(0.0, 0.0, 0.0);
		beginEditCP(transform, Transform::MatrixFieldMask);{
			transform->setMatrix(m);
		};endEditCP(transform, Transform::MatrixFieldMask);
	}else{
		std::cout << "CFlystickTranslationResetTool: Found no parenting transform to reset!" << std::endl;
	}

	m_bToolActive = false;
}

void CameraController::setCamera( CameraPtr camera )
{
	m_data->camera = camera;
	m_data->camera->addStandardParameters(); // subsequent casts are safe because of this
	m_data->resolution = staticPointerCast<V2iData>( m_data->camera->parameters()["resolution"] );
	m_data->screenWindow = staticPointerCast<Box2fData>( m_data->camera->parameters()["screenWindow"] );
	m_data->clippingPlanes = staticPointerCast<V2fData>( m_data->camera->parameters()["clippingPlanes"] );
	m_data->projection = staticPointerCast<StringData>( m_data->camera->parameters()["projection"] );
	if( m_data->projection->readable()=="perspective" )
	{
		m_data->fov = staticPointerCast<FloatData>( m_data->camera->parameters()["projection:fov"] );
	}
	else
	{
		m_data->fov = 0;
	}
	
	TransformPtr transform = m_data->camera->getTransform();
	m_data->transform = runTimeCast<MatrixTransform>( transform );
	if( !m_data->transform )
	{
		m_data->transform = new MatrixTransform( transform ? transform->transform() : M44f() );
		m_data->camera->setTransform( m_data->transform );
	}

	m_data->centreOfInterest = 1;
}

void  MoveManipulator::doMovement(TransformPtr t,
								  Int32 coord,
								  Real32 value,
								  const Vec3f		&translation,
								  const Quaternion	&rotation,
								  const Vec3f		&scaleFactor,
								  const Quaternion	&scaleOrientation )
{
	Vec3f trans(0.0f, 0.0f, 0.0f);
	trans[coord] = value;

	Matrix ma, mb, mc, md, me;
	
	ma.setTranslate( -translation        );
	mb.setRotate   (  rotation.inverse() );
	mc.setTransform(  trans              );
	md.setRotate   (  rotation           );
	me.setTranslate(  translation        );
	beginEditCP(t, Transform::MatrixFieldMask);
	{
		t->editMatrix().multLeft(ma);
		t->editMatrix().multLeft(mb);
		t->editMatrix().multLeft(mc);
		t->editMatrix().multLeft(md);
		t->editMatrix().multLeft(me);
	}	
	endEditCP(t, Transform::MatrixFieldMask);
}

// redraw the window
void display(void)
{
   Profiler::the().StartProfile("Frame");
   unsigned i;
   for (i=0; i<numFirst; ++i) {
     TransformPtr trf = TransformPtr::dcast(first->getChild(i)->getCore());
     beginEditCP(trf);
     trf->getMatrix()[3] += Vec4f((rand()/Real32(RAND_MAX)-0.5f),
				  (rand()/Real32(RAND_MAX)-0.5f),
				  (rand()/Real32(RAND_MAX)-0.5f), 0.0f);
     endEditCP(trf);
   }
   for (i=0; i<numSecond; ++i) {
     TransformPtr trf = TransformPtr::dcast(second->getChild(i)->getCore());
     beginEditCP(trf);
     trf->getMatrix()[3] += Vec4f((rand()/Real32(RAND_MAX)-0.5f),
				  (rand()/Real32(RAND_MAX)-0.5f),
				  (rand()/Real32(RAND_MAX)-0.5f), 0.0f);
     endEditCP(trf);
   }

   bool result = all->apply(first, second);

   OSGRAPIDCollision& col = (OSGRAPIDCollision&)all->getData();     
   SLOG << col.getNumContacts() << " contacts with " 
	<< col.getNumBVolTests() << " BVolTests/"
	<< col.getNumMixedTests() << " MixedTests/"
	<< col.getNumPrimTests() << " TriTests  " 
	<< std::endl;
   
   Profiler::the().EndProfile("Frame");
   mgr->redraw();
}

CameraNode::CameraNode( TransformPtr pTransform, Frustum const &frustum ) 
	      : SceneNode( INVALID_ACTOR_ID, NULL, RenderPass_0, pTransform ),
	      m_Frustum( frustum ),
	      m_IsActive( true ),
	      m_IsDebugCamera( false ),
         m_pTarget( shared_ptr<SceneNode>() ),
	      m_CamOffsetVector( 0.0f, 1.0f, -10.0f, 0.0f ),
         m_View( Mat4x4::LookAt( pTransform->GetToWorldPosition(), pTransform->GetToWorldPosition() + pTransform->GetForward(), g_Up ) )
   {
   }

//////////////////////////////////////////////////////////////////////////
//! build a box
//////////////////////////////////////////////////////////////////////////
void buildBox(void)
{
    Vec3f Lengths(frand()*2.0+0.5, frand()*2.0+0.5, frand()*2.0+0.5);
    Matrix m;
    //create OpenSG mesh
    GeometryPtr box;
    NodePtr boxNode = makeBox(Lengths.x(), Lengths.y(), Lengths.z(), 1, 1, 1);
    box = GeometryPtr::dcast(boxNode->getCore());
    SimpleMaterialPtr box_mat = SimpleMaterial::create();
    beginEditCP(box_mat);
        box_mat->setAmbient(Color3f(0.0,0.0,0.0));
        box_mat->setDiffuse(Color3f(0.0,1.0 ,0.0));
    endEditCP(box_mat);
    beginEditCP(box, Geometry::MaterialFieldMask);
        box->setMaterial(box_mat);
    endEditCP(box, Geometry::MaterialFieldMask);
    TransformPtr boxTrans;
    NodePtr boxTransNode = makeCoredNode<Transform>(&boxTrans);
    m.setIdentity();
    Real32 randX = frand()*10.0-5.0;
    Real32 randY = frand()*10.0-5.0;
    m.setTranslate(randX, randY, 10.0);
    beginEditCP(boxTrans, Transform::MatrixFieldMask);
        boxTrans->setMatrix(m);
    endEditCP(boxTrans, Transform::MatrixFieldMask);

    //create ODE data
    PhysicsBodyPtr boxBody = PhysicsBody::create(physicsWorld);
    beginEditCP(boxBody, PhysicsBody::PositionFieldMask);
        boxBody->setPosition(Vec3f(randX, randY, 10.0));
    endEditCP(boxBody, PhysicsBody::PositionFieldMask);
    boxBody->setBoxMass(1.0, Lengths.x(), Lengths.y(), Lengths.z());

    PhysicsBoxGeomPtr boxGeom = PhysicsBoxGeom::create();
    beginEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask  | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
        boxGeom->setBody(boxBody);
        boxGeom->setSpace(physicsSpace);
        boxGeom->setLengths(Lengths);
        boxGeom->setCategoryBits(BoxCategory);
    endEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);

    //add attachments
    beginEditCP(boxNode, Node::AttachmentsFieldMask);
        boxNode->addAttachment(boxGeom);
    endEditCP(boxNode, Node::AttachmentsFieldMask);
    beginEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
        boxTransNode->addAttachment(boxBody);
        boxTransNode->addChild(boxNode);
    endEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);

    //add to SceneGraph
    beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
        spaceGroupNode->addChild(boxTransNode);
    endEditCP(spaceGroupNode, Node::ChildrenFieldMask);
}

//////////////////////////////////////////////////////////////////////////
//! build a sphere
//////////////////////////////////////////////////////////////////////////
void buildSphere(void)
{
    Real32 Radius(frand()*1.5+0.2);
    Matrix m;
    //create OpenSG mesh
    GeometryPtr sphere;
    NodePtr sphereNode = makeSphere(2, Radius);
    sphere = GeometryPtr::dcast(sphereNode->getCore());
    SimpleMaterialPtr sphere_mat = SimpleMaterial::create();
    beginEditCP(sphere_mat);
    sphere_mat->setAmbient(Color3f(0.0,0.0,0.0));
    sphere_mat->setDiffuse(Color3f(0.0,0.0,1.0));
    endEditCP(sphere_mat);
    beginEditCP(sphere, Geometry::MaterialFieldMask);
    sphere->setMaterial(sphere_mat);
    endEditCP(sphere);
    TransformPtr sphereTrans;
    NodePtr sphereTransNode = makeCoredNode<Transform>(&sphereTrans);
    m.setIdentity();
    Real32 randX = frand()*10.0-5.0;
    Real32 randY = frand()*10.0-5.0;
    m.setTranslate(randX, randY, 10.0);
    beginEditCP(sphereTrans, Transform::MatrixFieldMask);
    sphereTrans->setMatrix(m);
    endEditCP(sphereTrans);
    //create ODE data
    PhysicsBodyPtr sphereBody = PhysicsBody::create(physicsWorld);
    beginEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
        sphereBody->setPosition(Vec3f(randX, randY, 10.0));
        sphereBody->setAngularDamping(0.0001);
    endEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
    sphereBody->setSphereMass(0.4,Radius);

    PhysicsSphereGeomPtr sphereGeom = PhysicsSphereGeom::create();
    beginEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
        sphereGeom->setBody(sphereBody);
        sphereGeom->setSpace(physicsSpace);
        sphereGeom->setRadius(Radius);
        sphereGeom->setCategoryBits(SphereCategory);
    endEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
    
    //add attachments
    beginEditCP(sphereNode, Node::AttachmentsFieldMask);
    sphereNode->addAttachment(sphereGeom);
    endEditCP(sphereNode);
    beginEditCP(sphereTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
    sphereTransNode->addAttachment(sphereBody);
    sphereTransNode->addChild(sphereNode);
    endEditCP(sphereTransNode);
    //add to SceneGraph
    beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
    spaceGroupNode->addChild(sphereTransNode);
    endEditCP(spaceGroupNode);
}

void GuiMeshRender::ProcessEntities(const EntityMap &entities) {

	if (entities.empty()) {
		//printf("Warning: GuiMeshRender: Entity list is empty\n");
		return;
	}

	EntityMap::const_iterator it, ite;

	GuiMeshPtr mesh;
	TransformPtr transform;

	mat4 model, view, projection, model_view, mvp;
	mat3 normal;

	// warning: make sure the values here are all floats
	projection = glm::ortho(0.0f, 800.0f, 600.0f, 0.0f, -1.0f, 1.0f);

	for (it = entities.begin(), ite = entities.end(); it != ite; ++it) {
		mesh = gui_mesh_mapper_(it->second);
		transform = transform_mapper_(it->second);

		model = transform->world();
		model_view = model;				// camera does not need to effect this
		mvp = projection * model_view;
		normal = inverse(transpose(mat3(model_view)));

		shared_ptr<BasicMaterial> material = boost::dynamic_pointer_cast<BasicMaterial>(mesh->material);

		vec4 light_pos = material->light_position_;

		// hack to have light move with world
		// todo: implement light as entity
		material->light_position_ = model_view * light_pos;

		// do things like setup colors and lights
		// and attach shader program
		mesh->material->PreRender();

		material->light_position_ = light_pos;

		// push matrices up
		mesh->material->PushMatrices(model_view, projection, mvp, normal);

		// call draw
		mesh->geometry->Draw();

		// let go of shader program
		mesh->material->PostRender();
	}
}

void PhysicsSystem::CheckCup(const TransformPtr &ball_transform){
	using glm::vec2; 

	float radius = 0.05f;

	BallComponentPtr ball_comp = ball_comp_mapper_(ball_);
	TileComponentPtr curr_tile = tile_comp_mapper_(ball_comp->current_tile);
	VolumePtr cup_vol = volume_mapper_(curr_tile->cup);
	TransformPtr cup_transform = transform_mapper_(curr_tile->cup);

	// create ball projection
	vec3 proj = Project(ball_transform->position(), cup_vol->normal, cup_vol->vertices[0]);

	// project cup vertices to xz plane
	vector<vec2> projected_vertices;
	for (int j = 0, sizej = cup_vol->vertices.size(); j < sizej; ++j) {
		vec3 v = cup_vol->vertices[j];
		vec2 p(v.x, v.z);

		projected_vertices.push_back(p);
	}

	// project ball to xz plane
	vec2 point(proj.x, proj.z);

	// check to see if ball overlaps hole
	bool inter = PointInPolygon(point, projected_vertices);

	// does ball overlap?
	if (inter) {
		float dist_from_cup = glm::length(ball_transform->position() - cup_transform->position());

		//if ball is close enough to go in hole and moving slow enough, ball went in cup (stop ball)
		if(dist_from_cup < MADE_CUP_RADIUS && glm::length(ball_comp->velocity) < MAX_CUP_ENTRY_SPEED ) {
			ball_comp->velocity = vec3();
			ball_comp->acceleration = vec3();
			ball_comp->in_cup = true;
		}
		//if ball is on lip, alter accel to go towards center
		else if(dist_from_cup > MADE_CUP_RADIUS && dist_from_cup < CUP_LIP_RADIUS) {
			ball_comp->acceleration += glm::normalize(cup_transform->position() - ball_transform->position()) * LIP_ACCEL;
		}
		else{}
	}
}

void Particles::duplicate(Vec3f deltaPos, Quaternion deltaRot)
{
	NodePtr copyTransNode = cloneTree(particleTransNode);
	TransformPtr copyTrans = Transform::create();
	Matrix m;
	m.setIdentity();
	m.setRotate(deltaRot);
	m.setTranslate(deltaPos);
	beginEditCP(copyTrans);
		copyTrans->setMatrix(m);
	endEditCP(copyTrans);
	beginEditCP(copyTransNode);
		copyTransNode->setCore(copyTrans);
	endEditCP(copyTransNode);
	beginEditCP(particleTransNode);
		particleTransNode->addChild(copyTransNode);
	endEditCP(particleTransNode);
} // duplicate

void PhysicsSystem::ResolveCollision(const TransformPtr &ball_transform, const vec3 &normal, const vec3 &intersection) {
	BallComponentPtr ball_comp = ball_comp_mapper_(ball_);

	ball_transform->set_position(intersection);

	vec3 direction = ball_comp->velocity;
	vec3 w = glm::dot(normal, -direction) * normal;
	vec3 result = w + (w + direction);
	ball_comp->velocity = result;
}

void SkyBackgroundPluginForm::setLightSettings( LightPtr light, LightSettingsHandler &handler )
{
	beginEditCP(light);
	light->setAmbient(handler.ambient);
	light->setDiffuse(handler.diffuse);
	light->setSpecular(handler.specular);
	endEditCP(light);

	NodePtr beacon = light->getBeacon();
	if (beacon == NullFC)
	{
		TransformPtr beaconTransform = Transform::create();
		beacon = Node::create();
		beginEditCP(beacon);
		beacon->setCore(beaconTransform);
		endEditCP(beacon);

	}
	TransformPtr transform = TransformPtr::dcast(beacon->getCore());
	if (transform == NullFC)
	{
		TransformPtr beaconTransform = Transform::create();
		beginEditCP(beacon);
		beacon->setCore(beaconTransform);
		endEditCP(beacon);
		transform = beaconTransform;
	}
	Matrix m;
	float transFactor = LightDistanceExSlider->value();
	Vec3f translate = Vec3f(handler.direction.x() * transFactor, handler.direction.y() * transFactor,
		handler.direction.z() * transFactor);
	if (zUpCheckBox->isChecked())
		m.setTranslate(translate.x(), translate.y(), translate.z());
	else
		m.setTranslate(translate.x(), translate.z(), -translate.y());
	beginEditCP(transform);
	transform->setMatrix(m);
	endEditCP(transform);
}

void Particles::createSymmetricEmitterLine(Vec3f dir, Real32 dist, UInt16 num)
{
	NodePtr localTransNode;
	TransformPtr localTrans;
	Matrix m;
	dir.normalize();
	for (int i = 1; i < num; i++)
	{
		localTransNode = Node::create();
		localTrans = Transform::create();
		m.setIdentity();
		m.setTranslate(dir*(i*dist));
		beginEditCP(localTrans, Transform::MatrixFieldMask);
			localTrans->setMatrix(m);
		endEditCP(localTrans, Transform::MatrixFieldMask);
		beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
			localTransNode->setCore(localTrans);
			localTransNode->addChild(cloneTree(particleNode));
		endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
		beginEditCP(particleTransNode, Node::ChildrenFieldMask);
			particleTransNode->addChild(localTransNode);
		endEditCP(particleTransNode, Node::ChildrenFieldMask);

		localTransNode = Node::create();
		localTrans = Transform::create();
		m.setIdentity();
		m.setTranslate(dir*(-i*dist));
		beginEditCP(localTrans, Transform::MatrixFieldMask);
			localTrans->setMatrix(m);
		endEditCP(localTrans, Transform::MatrixFieldMask);
		beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
			localTransNode->setCore(localTrans);
			localTransNode->addChild(cloneTree(particleNode));
		endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
		beginEditCP(particleTransNode, Node::ChildrenFieldMask);
			particleTransNode->addChild(localTransNode);
		endEditCP(particleTransNode, Node::ChildrenFieldMask);
	} // for
} // createSymmetricEmitterLine

void PhysicsSystem::UpdateCollision(const TransformPtr &ball_transform) {
	BallComponentPtr ball_comp = ball_comp_mapper_(ball_);
	vec3 start = ball_transform->position();
	vec3 end = start + ball_comp->velocity * Time::GetDeltaTime();

	vec3 normal, penetration;

	unordered_map<VolumePtr, EntityPtr>::iterator it;
	for (it = wall_map_.begin(); it != wall_map_.end(); ++it) {
		if (Intersect(start, end, it->first, normal, penetration)) {
			ResolveCollision(ball_transform, normal, penetration);
		}
	}
}

//.........这里部分代码省略.........
	Geometry::LengthsFieldMask	|
	Geometry::IndicesFieldMask	|
	Geometry::PositionsFieldMask	|
	Geometry::NormalsFieldMask      |
        Geometry::MaterialFieldMask     |
	Geometry::ColorsFieldMask	|
        Geometry::DlistCacheFieldMask
	);
	
	geo->setTypes(type);
	geo->setLengths(length);
	geo->setIndices(indices);
	geo->setPositions(pos);
	geo->setNormals(norms);
        geo->setMaterial(mat);
	//geo->setColors(colors);
        geo->setDlistCache(false);

    endEditCP(geo,
        Geometry::TypesFieldMask	|
	Geometry::LengthsFieldMask	|
	Geometry::IndicesFieldMask	|
	Geometry::PositionsFieldMask	|
	Geometry::NormalsFieldMask	|
        Geometry::MaterialFieldMask     |
	Geometry::ColorsFieldMask	|
        Geometry::DlistCacheFieldMask
	);
    
    PointLightPtr pLight = PointLight::create();
    NodePtr root = Node::create();
    NodePtr water = Node::create();
    NodePtr pLightTransformNode = Node::create();
    TransformPtr pLightTransform = Transform::create();
    NodePtr pLightNode = Node::create();
    
    beginEditCP(pLightNode);
        pLightNode->setCore(Group::create());
    endEditCP(pLightNode);
    
    Matrix m;
    m.setIdentity();
    m.setTranslate(50,25,50);
    
    beginEditCP(pLightTransform);
        pLightTransform->setMatrix(m);
    endEditCP(pLightTransform);
    
    //we add a little spehere that will represent the light source
    GeometryPtr sphere = makeSphereGeo(2,2);

    SimpleMaterialPtr sm = SimpleMaterial::create();

    beginEditCP(sm, SimpleMaterial::DiffuseFieldMask |
                    SimpleMaterial::LitFieldMask);
    {
        sm->setLit(false);
        sm->setDiffuse(Color3f(1,1,1));
    }
    endEditCP  (sm, SimpleMaterial::DiffuseFieldMask |
                    SimpleMaterial::LitFieldMask);

    beginEditCP(sphere, Geometry::MaterialFieldMask);
    {
        sphere->setMaterial(sm);
    }

void display(void)
{
    Real32 time = glutGet(GLUT_ELAPSED_TIME );
    
    //create the Quaternion the describes the rotation of
    //the planet around the sun
    Quaternion planetRot = Quaternion(Vec3f(0,1,0), time/float(1000));
    
    //now the rotation of the moon around the planet
    //the division by 12 speeds up the rotation by 12 compared to the
    //planet rotation
    Quaternion moonRot = Quaternion(Vec3f(0,1,0), time/float(1000/12));
    
    //generate the Matrices
    Matrix p,m;
    
    p.setIdentity();
    m.setIdentity();
    
    p.setRotate(planetRot);
    m.setRotate(moonRot);
    
    p.setTranslate(20,0,0);
    m.setTranslate(8,0,0);

    beginEditCP(planetTransform, Transform::MatrixFieldMask);
        planetTransform->setMatrix(p);
    endEditCP(planetTransform, Transform::MatrixFieldMask);
    
    beginEditCP(moonTransform, Transform::MatrixFieldMask);
        moonTransform->setMatrix(m);
    endEditCP(moonTransform, Transform::MatrixFieldMask);
    
    mgr->redraw();
}

void 
display(void)
{
	Matrix m1, m2;

	m1.setRotate( tball.getRotation() );
	m2.setTranslate( tball.getPosition() );
	
	m1.mult( m2 );
	cam_trans->editSFMatrix()->setValue( m1 );


    // move the object
    
    float t = glutGet(GLUT_ELAPSED_TIME);
    Quaternion q;
    
    q.setValueAsAxisDeg(0, 1, 0, t / 5000);
    
    m1.setTransform(Vec3f(osgsin(t / 500.), 0, osgcos(t / 500)), q);
                    
    tr->setMatrix(m1);
    
	if ( doRender )
		win->render( ract );
	else
		win->draw( dact );
}

    virtual void update(const UpdateEventPtr e)
    {
        Real32 RotateRate(1.0f);

        Matrix RotMat;
        RotMat.setRotate(Quaternion(Vec3f(0.0,1.0,0.0),RotateRate*e->getElapsedTime()));

        Matrix NewMat(RootTransformCore->getMatrix());
        NewMat.multLeft(RotMat);

        beginEditCP(RootTransformCore, Transform::MatrixFieldMask);
            RootTransformCore->setMatrix(NewMat);
        endEditCP(RootTransformCore, Transform::MatrixFieldMask);
    }

   virtual void keyPressed(const KeyEventPtr e)
   {
       if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
       {
            TutorialWindowEventProducer->closeWindow();
       }

	   switch(e->getKey())
	   {
	   case KeyEvent::KEY_S:
		   statFlag = !statFlag;
		   mgr->setStatistics(statFlag);
		   break;
       case KeyEvent::KEY_EQUALS:
           {
               Vec3f Translation;
               Quaternion Rotation;
               Vec3f Scale;
               Quaternion ScaleOrient;
               Matrix ThePointLightMat = ThePointLightBeaconTransform->getMatrix();
               ThePointLightMat.getTransform(Translation,Rotation,Scale,ScaleOrient);
               Translation = Translation + Vec3f(0.0,10.0,0.0);
               ThePointLightMat.setTranslate(Translation);
               beginEditCP(ThePointLightBeaconTransform);
                   ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
               endEditCP(ThePointLightBeaconTransform);
           }
           break;
       case KeyEvent::KEY_MINUS:
           {
               Vec3f Translation;
               Quaternion Rotation;
               Vec3f Scale;
               Quaternion ScaleOrient;
               Matrix ThePointLightMat = ThePointLightBeaconTransform->getMatrix();
               ThePointLightMat.getTransform(Translation,Rotation,Scale,ScaleOrient);
               Translation = Translation + Vec3f(0.0,-10.0,0.0);
               ThePointLightMat.setTranslate(Translation);
               beginEditCP(ThePointLightBeaconTransform);
                   ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
               endEditCP(ThePointLightBeaconTransform);
           }
           break;
       case KeyEvent::KEY_T:
            beginEditCP(TheBlinnMat, BlinnMaterial::DiffuseTextureFieldMask);
            endEditCP(TheBlinnMat, BlinnMaterial::DiffuseTextureFieldMask);
           break;
	   }
   }