Esempio n. 1
0
//-------------------------------
//
//-------------------------------
void Vector3::GetQuaternion( Quaternion& qRot )
{
	Vector3		vDir;
	vDir.x = x;
	vDir.y = y;
	vDir.z = z;
	vDir.Normalize();
	vDir *= -1;

	Matrix44		matWorld;
	matWorld.SetWorld( Vector3( 0.0F, 0.0F, 0.0F ), vDir, Vector3( 0.0F, 0.0F, 1.0F ) );

	qRot = matWorld.GetQuaternion();	
} //Vector3::GetQuaternion
Esempio n. 2
0
void State::integrate(State& state, float t, float dt)
{
	Derivative a = Derivative::evaluate(state, t);
	Derivative b = Derivative::evaluate(state, t, dt*0.5f, a);
	Derivative c = Derivative::evaluate(state, t, dt*0.5f, b);
	Derivative d = Derivative::evaluate(state, t, dt, c);
	
	state.position += 1.0f/6.0f * dt * (a.velocity + 2.0f*(b.velocity + c.velocity) + d.velocity);
	state.momentum += 1.0f/6.0f * dt * (a.force + 2.0f*(b.force + c.force) + d.force);
	state.orientation += 1.0f/6.0f * dt * (a.spin + 2.0f*(b.spin + c.spin) + d.spin);
	state.angularMomentum += 1.0f/6.0f * dt * (a.torque + 2.0f*(b.torque + c.torque) + d.torque);
	
	const float e = 0.2;
	const float u = 0.97;
	std::vector<Collision> collision = collisions(state);
	const float scale = 1.f/float(collision.size());
	for(auto& c : collision)
	{
		if(c.direction.dot(state.momentum) > 0.f)
			continue;
		state.position += c.direction * c.magnitude;
		
		const Vector3 r = c.point - state.position;
		Vector3 velocityAtPoint = state.velocity + state.angularVelocity.cross(r);
		const float vn = min (0.f, velocityAtPoint.dot(c.direction));
		
		Matrix44 rotation = state.orientation.matrix();
		Matrix44 transposeRotation = rotation.transpose();
		Matrix44 i = rotation * state.inverseInertiaTensor * transposeRotation;
		
		const float k = state.inverseMass + r.cross(c.direction).dot(i * r.cross(c.direction));
		const float j = -(1+e) * vn / k;
		
		state.momentum += c.direction * j * scale;
		state.angularMomentum += r.cross(c.direction) * j * scale;
		
		Vector3 tangentVelocity = velocityAtPoint - c.direction * velocityAtPoint.dot(c.direction);
		if(tangentVelocity.lengthSquared() > epsilonSquared)
		{
			Vector3 tangent = tangentVelocity.unit();
			const float vt = velocityAtPoint.dot(tangent);
			const float kt = state.inverseMass + r.cross(tangent).dot(i * r.cross(tangent));
			float jt = clamp(-vt/kt, -u*j, u*j);
			state.momentum += tangent * jt * scale;
			state.angularMomentum += r.cross(tangent) * jt * scale;
		}
	}
	state.recalculate();
}
Esempio n. 3
0
	gh::Vector3 GetCameraPointingVector( const Vector3& eulerAngles )
	{
		//rotate about z
		Matrix44 pitchMat = Matrix44::CreatePitchRotationMatrixDegrees( eulerAngles.y );
		//roll goes about x, from y to z, this is the vertical sweeping in this camera
		Matrix44 rollMat = Matrix44::CreateRollRotationMatrixDegrees( eulerAngles.x );

		Matrix44 currentRotation = pitchMat * rollMat;

        Vector3 zv = Vector3( 0.f, 0.f, -1.f );

		Vector3 direction = currentRotation.transformDirection( zv );

		return direction;
	}
Esempio n. 4
0
	/** TODO: avoid recalculating when nothing changed */
	Matrix44 Entity2D::GetCenterTransformationMatrix()
	{
		Matrix44 matrix = Matrix44::Identity;
		matrix.Scale(Vector3::Create(m_vScale.X, m_vScale.Y, 1.0f));
		matrix.Rotate(Vector3::Create(0.0f, 0.0f, m_fRotation*Math::DegToRadFactor));		
		matrix.Translate(Vector3::Create(m_vPosition.X, m_vPosition.Y, 0.0f));

		// TODO: use type checking at initialization time in AddChild() and only use static_cast here		
		if(Entity2D* pEntity2D = GetAncestor<Entity2D>())
		{
			matrix *= pEntity2D->GetTransformationMatrix();
		}
		
		return matrix;
	}
Esempio n. 5
0
 const Matrix44 CreateBoundsTransform(
     const Vector2& top_left,
     const Vector2& bottom_right
 )
 {
     Matrix44 result;
     result.clear();
     result(0, 0) = 1.0 / (bottom_right(0) - top_left(0));
     result(0, 3) = -top_left(0) * result(0, 0);
     result(1, 1) = 1.0 / (bottom_right(1) - top_left(1));
     result(1, 3) = -top_left(1) * result(1, 1);
     result(2, 3) = 0.5;
     result(3, 3) = 1;
     return result;
 }
Esempio n. 6
0
//what to do when the image has to be draw
void Game::render(void)
{
	//set the clear color (the background color)
	glClearColor(0.0, 0.0, 0.0, 1.0);

	// Clear the window and the depth buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	//set the camera as default
	camera->enable();

	//set flags
	glDisable(GL_BLEND);
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);
   
	//create model matrix for cube
	Matrix44 m;
	m.rotate(time, Vector3(0, 1, 0));

	if(shader)
	{
		//enable shader
		shader->enable();

		//upload uniforms
		shader->setUniform("u_color", Vector4(1,1,1,1));
		shader->setUniform("u_viewprojection", camera->viewprojection_matrix );
		shader->setUniform("u_texture", texture);
		shader->setUniform("u_model", m);
		shader->setUniform("u_time", time);

		//do the draw call
		mesh->render( GL_TRIANGLES );

		//disable shader
		shader->disable();
	}

	//Draw the floor grid
	drawGrid();

	//render the FPS, Draw Calls, etc
	drawText(2, 2, getGPUStats(), Vector3(1, 1, 1), 2);

	//swap between front buffer and back buffer
	SDL_GL_SwapWindow(this->window);
}
Esempio n. 7
0
void bhkTransformShape::CalcMassProperties(float density, bool solid, float &mass, float &volume, Vector3 &center, InertiaMatrix& inertia)
{
    center = transform.GetTranslation();
    mass = 0.0f, volume = 0.0f;
    inertia = InertiaMatrix::IDENTITY;
    if (shape != NULL)
    {
        Matrix44 transform_transposed = transform.Transpose();
        shape->CalcMassProperties(density, solid, mass, volume, center, inertia);
        center = transform * center;

        Matrix44 tm(inertia.Submatrix(0, 0));
        Matrix44 im = transform_transposed * tm * transform;
        inertia = InertiaMatrix(im.GetRotation());
    }
}
Esempio n. 8
0
void Matrix44::Transpose( Matrix44& out ) const
{
    float tmp[ 16 ];

    tmp[  0 ] = m[  0 ];
    tmp[  1 ] = m[  4 ];
    tmp[  2 ] = m[  8 ];
    tmp[  3 ] = m[ 12 ];
    tmp[  4 ] = m[  1 ];
    tmp[  5 ] = m[  5 ];
    tmp[  6 ] = m[  9 ];
    tmp[  7 ] = m[ 13 ];
    tmp[  8 ] = m[  2 ];
    tmp[  9 ] = m[  6 ];
    tmp[ 10 ] = m[ 10 ];
    tmp[ 11 ] = m[ 14 ];
    tmp[ 12 ] = m[  3 ];
    tmp[ 13 ] = m[  7 ];
    tmp[ 14 ] = m[ 11 ];
    tmp[ 15 ] = m[ 15 ];

    out.InitFrom( tmp );
    
#if DEBUG
    ae3d::CheckNaN( out );
#endif
}
	int ParticleGenerator::TesselateLine(Particle* pParticle, Vertex3D* pVertices, int current, const Vector3& vScale)
	{
		Vector3 vDir = (pParticle->Pos - pParticle->PreviousPos).Normalized();		
		pVertices[current+0].UV = Vector2::Zero; pVertices[current+0].Pos = Vector3::Zero;
		pVertices[current+1].UV = Vector2::One;  pVertices[current+1].Pos = vDir*vScale*m_fSparkFactor;
		pParticle->PreviousPos = pParticle->Pos;

		Matrix44 transform = Matrix44::Identity;
		transform.SetTranslation(m_bApplyWorldTransform ? super::GetWorldTransform().TransformVect(pParticle->Pos) : pParticle->Pos);
		for(int i=0; i<2; ++i)
		{
			pVertices[current+i].Pos = transform.TransformVect(pVertices[current+i].Pos);
			pVertices[current+i].color = Color::Create(m_ParticleColor.R, m_ParticleColor.G, m_ParticleColor.B, pParticle->Alpha);
		}
		return 2;
	}
	Matrix44 SimpleSceneGraph::calculateRelativeTransform(const Matrix44& absoluteTransform) const
	{
		if (parent == nullptr)
		{
			return absoluteTransform;
		}

		/*
		 * Find the transform for this graph (Gr) relative to the absolute parent transform (Pa) that matches the
		 * absolute transform (Ga) i.e. such that: Ga = Pa * Gr or Gr = Ga * Pa-1
		 */
		Matrix44 inverseParentAbsoluteTransform = parent->getAbsoluteTransform();
		inverseParentAbsoluteTransform.invert();

		return absoluteTransform * inverseParentAbsoluteTransform;
	}
			btTransform toBtTransform(const Matrix44& original)
			{
				btTransform transform;
				transform.setFromOpenGLMatrix(original.getData());

				return transform;
			}
Esempio n. 12
0
/**
 @brief 
 @date 2014-04-17
*/
bool cParticle::Move(int elapseTime)
{
	const float dt = (float)elapseTime * 0.001f;
	m_Velocity += Vector3(0, 3000.f * dt, 0);
	m_Pos += m_Velocity * dt;
	m_tm.SetWorld(m_Pos);

	Matrix44 mat;
	mat.SetRotationZ(m_Torq * dt);
	m_localTm *= mat;

	if (m_Pos.y > 1000.f)
		return false;

	return true;
}
Esempio n. 13
0
void UpdateCamera()
{
	Vector3 dir = g_lookAtPos - g_camPos;
	dir.Normalize();
	g_matView.SetView(g_camPos, dir, Vector3(0,1,0));
	graphic::GetDevice()->SetTransform(D3DTS_VIEW, (D3DXMATRIX*)&g_matView);
}
Esempio n. 14
0
//---------------------
//For a local rotation you have to:
//1. Put the Matrix at 0,0,0 world coordinates after memorizing the original position
//2. Make a normal rotation
//3. Put back Matrix to its original position
//---------------------
void Matrix44::rotateLocal(double radians, Vector axis){
    //1
    Matrix44 r  = Matrix44();
    r.setRotationMatrix(radians,axis);
    
    Vector   pos= Vector(3);
    pos.takePosition(*this);

    setPosition(0,0,0);
    
    //2
    operator=(r*(*this));
    
    //3
    setPosition(pos[0], pos[1], pos[2]);
}
Esempio n. 15
0
//랜더
void Render(int timeDelta)
{
	//화면 청소
	if (SUCCEEDED(g_pDevice->Clear( 
		0,			//청소할 영역의 D3DRECT 배열 갯수		( 전체 클리어 0 )
		NULL,		//청소할 영역의 D3DRECT 배열 포인터		( 전체 클리어 NULL )
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL,	//청소될 버퍼 플레그 ( D3DCLEAR_TARGET 컬러버퍼, D3DCLEAR_ZBUFFER 깊이버퍼, D3DCLEAR_STENCIL 스텐실버퍼
		D3DCOLOR_XRGB(255, 255, 255),			//컬러버퍼를 청소하고 채워질 색상( 0xAARRGGBB )
		1.0f,				//깊이버퍼를 청소할값 ( 0 ~ 1 0 이 카메라에서 제일가까운 1 이 카메라에서 제일 먼 )
		0					//스텐실 버퍼를 채울값
		)))
	{
		//화면 청소가 성공적으로 이루어 졌다면... 랜더링 시작
		g_pDevice->BeginScene();

		static float y = 0;
		y += timeDelta / 1000.f;
		// 각도가 2*PI 에 이르면 0으로 초기화한다.
		if (y >= 6.28f)
			y = 0;

		Matrix44 rx, ry, r;
		rx.SetRotationX(MATH_PI/4.f); 	// x축으로 45도 회전시킨다.
		ry.SetRotationY(y); // y축으로 회전
		r = rx*ry;
		g_pDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&r);


		Matrix44 rry;
		rry.SetRotationY(-y); // y축으로 회전
		Vector3 dir = global->lightDir * rry;
		global->light.Direction = *(D3DXVECTOR3*)&dir;
		g_pDevice->SetLight(0, &global->light); // 광원 설정.


		g_pDevice->SetMaterial(&global->mtrl);
		g_pDevice->SetStreamSource( 0, global->vb, 0, sizeof(Vertex) );
		g_pDevice->SetIndices(global->ib);
		g_pDevice->SetFVF( Vertex::FVF );
		g_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, global->vtxSize, 0, global->faceSize);

		//랜더링 끝
		g_pDevice->EndScene();
		//랜더링이 끝났으면 랜더링된 내용 화면으로 전송
		g_pDevice->Present( NULL, NULL, NULL, NULL );
	}
}
Esempio n. 16
0
bool
RendererServices::get_inverse_matrix (Matrix44 &result, TransformationPtr xform)
{
    bool ok = get_matrix (result, xform);
    if (ok)
        result.invert ();
    return ok;
}
Esempio n. 17
0
void Init()
{
	ReadModelFile("../../media/model_normal.dat", g_vertices, g_indices, g_normals);

	g_matWorld1.SetTranslate(Vector3(0,0,0));

	Vector3 dir = g_cameraLookat - g_cameraPos;
	dir.Normalize();
	g_matView.SetView(g_cameraPos, dir, Vector3(0,1,0));
	g_matProjection.SetProjection( MATH_PI / 4.f, 1.0f, 1.0f, 100.0f );

	RECT cr;
	::GetClientRect(g_hWnd, &cr);
	const float width = (float)(cr.right-cr.left);
	const float height = (float)(cr.bottom - cr.top);
	g_matViewPort.SetViewport(width, height);
}
inline void CGLFixedFunctionPipelineManager::SetWorldViewProjectionTransform( const Matrix44& matWorld,
															 const Matrix44& matView,
															 const Matrix44& matProj )
{
	m_matView       = matView;
	m_matWorld      = matWorld;
	m_matProjection = matProj;
	Matrix44 matWorldView = matView * matWorld;

	glMatrixMode( GL_MODELVIEW );
	glLoadMatrixf( matWorldView.GetData() );
//	glLoadIdentity(); // debug - reset the projection matrix

	glMatrixMode( GL_PROJECTION );
	glLoadMatrixf( matProj.GetData() );
//	glLoadIdentity(); // debug - reset the projection matrix
}
Esempio n. 19
0
bool
RendererServices::get_inverse_matrix (Matrix44 &result, ustring to)
{
    bool ok = get_matrix (result, to);
    if (ok)
        result.invert ();
    return ok;
}
Esempio n. 20
0
void Plane::shoot(bool thrownByPlayer){
	if(bulletsShoot >= numBullets) return;

	double time = (SDL_GetTicks() - lastBulletThrown) * 0.001;

	Matrix44 A = matrix_; A.traslateLocal(-2,0,0);
	Matrix44 B = A; A.traslateLocal(4, 0,0);
	
	if(time > cadencia){
		(BulletManager::getInstance())->shoot(A,thrownByPlayer);
		(BulletManager::getInstance())->shoot(B,thrownByPlayer);
		bulletsShoot+=2;
		lastBulletThrown = SDL_GetTicks();
		
		BASS_ChannelPlay(bulletSampleChannel,true);
	}
}
Esempio n. 21
0
	Common::Plane Transform_Plane_By_Mat44(const Plane& plane, const Matrix44& mat)
	{
		Vector4 v(plane.n, plane.d);

		// To transform normal, we can not use the matrix directly
		// See: http://www.songho.ca/opengl/gl_normaltransform.html
		Matrix44 matInvTranspose = mat.Inverse();
		matInvTranspose.Transpose();

		v = Common::Transform_Vec4_By_Mat44(v, matInvTranspose);

		Plane ret;
		ret.n = v.GetVec3();
		ret.d = v.w / ret.n.Normalize();

		return ret;
	}
	void Impl_CameraController_FirstPerson::UpdateRotating(float dx, float dy)
	{
		using namespace math;

		Matrix44 local = m_pObject->GetLocalTransform();
		Matrix44 parent = MatrixIdentity();
		if(m_pObject->GetParent())
		{
			parent = m_pObject->GetParent()->GetWorldTransform();
		}

		Vector3 axis_x = local.GetRow3(0);
		axis_x.Normalize();
		Vector3 axis_y = parent.GetRow3(1);
		axis_y.Normalize();
		
		Vector3 pos = local.GetRow3(3);

		local.SetRow3(3, Vector3(0, 0, 0));

		float step = D2R(0.1);

		local = local * MatrixRotationAxis(axis_x, dy * step) * MatrixRotationAxis(axis_y, dx * step);
		local.SetRow3(3, pos);
		m_pObject->SetLocalTransform(local);

		m_pCameraData->UpdateCamera();
	}
Esempio n. 23
0
// screen pixel 좌표 pos 값이 스프라이트 안에 있다면 true를 리턴한다.
bool cSprite::IsContain(const Vector2 &pos)
{
	Vector3 leftTop(0,0,0);
	Vector3 rightBottom = Vector3(m_rect.Width(), m_rect.Height(), 0);

	Matrix44 S;
	S.SetScale(m_scale);
	Matrix44 C;
	C.SetTranslate(-m_center);
	Matrix44 tm = S * C * m_accTM;
	leftTop *= tm;
	rightBottom *= tm;

	return ((leftTop.x <= pos.x) &&
		(leftTop.y <= pos.y) &&
		(rightBottom.x >= pos.x) &&
		(rightBottom.y >= pos.y));
}
bool
RendererServices::get_inverse_matrix (ShaderGlobals *sg, Matrix44 &result,
                                      ustring to)
{
    bool ok = get_matrix (sg, result, to);
    if (ok)
        result.invert ();
    return ok;
}
bool
RendererServices::get_inverse_matrix (ShaderGlobals *sg, Matrix44 &result,
                                      TransformationPtr xform, float time)
{
    bool ok = get_matrix (sg, result, xform, time);
    if (ok)
        result.invert ();
    return ok;
}
SimpleRenderer::SimpleRenderer ()
{
    Matrix44 M;  M.makeIdentity();
    camera_params (M, u_perspective, 90.0f,
                   0.1f, 1000.0f, 256, 256);

    // Set up getters
    m_attr_getters[ustring("camera:resolution")] = &SimpleRenderer::get_camera_resolution;
    m_attr_getters[ustring("camera:projection")] = &SimpleRenderer::get_camera_projection;
    m_attr_getters[ustring("camera:pixelaspect")] = &SimpleRenderer::get_camera_pixelaspect;
    m_attr_getters[ustring("camera:screen_window")] = &SimpleRenderer::get_camera_screen_window;
    m_attr_getters[ustring("camera:fov")] = &SimpleRenderer::get_camera_fov;
    m_attr_getters[ustring("camera:clip")] = &SimpleRenderer::get_camera_clip;
    m_attr_getters[ustring("camera:clip_near")] = &SimpleRenderer::get_camera_clip_near;
    m_attr_getters[ustring("camera:clip_far")] = &SimpleRenderer::get_camera_clip_far;
    m_attr_getters[ustring("camera:shutter")] = &SimpleRenderer::get_camera_shutter;
    m_attr_getters[ustring("camera:shutter_open")] = &SimpleRenderer::get_camera_shutter_open;
    m_attr_getters[ustring("camera:shutter_close")] = &SimpleRenderer::get_camera_shutter_close;
}
Esempio n. 27
0
	void PrimitiveBatch::begin_3d(const Matrix44& view_proj)
	{
		R_ASSERT(m_ready_to_draw==false);
		Matrix44 mat_transposed = view_proj.transposed();
		m_vsc_mat_viewproj[0] = mat_transposed.rows[0];
		m_vsc_mat_viewproj[1] = mat_transposed.rows[1];
		m_vsc_mat_viewproj[2] = mat_transposed.rows[2];
		m_vsc_mat_viewproj[3] = mat_transposed.rows[3];
		m_ready_to_draw = true;
	}
	int ParticleGenerator::TesselateQuad(Particle* pParticle, Vertex3D* pVertices, int current, const Vector3& vScale)
	{
		auto halfSize = pParticle->Size;
		pVertices[current+0].UV = Vector2::Create(0.0f, 1.0f); pVertices[current+0].Pos = Vector3::Create(-halfSize, -halfSize, 0.0f)*vScale;
		pVertices[current+1].UV = Vector2::Create(0.0f, 0.0f); pVertices[current+1].Pos = Vector3::Create(-halfSize, halfSize, 0.0f)*vScale;
		pVertices[current+2].UV = Vector2::Create(1.0f, 0.0f); pVertices[current+2].Pos = Vector3::Create(halfSize, halfSize, 0.0f)*vScale;
		pVertices[current+3].UV = Vector2::Create(0.0f, 1.0f); pVertices[current+3].Pos = Vector3::Create(-halfSize, -halfSize, 0.0f)*vScale;
		pVertices[current+4].UV = Vector2::Create(1.0f, 0.0f); pVertices[current+4].Pos = Vector3::Create(halfSize, halfSize, 0.0f)*vScale;
		pVertices[current+5].UV = Vector2::Create(1.0f, 1.0f); pVertices[current+5].Pos = Vector3::Create(halfSize, -halfSize, 0.0f)*vScale;
		
		Matrix44 transform = m_ViewInverse;
		transform.SetTranslation(m_bApplyWorldTransform ? super::GetWorldTransform().TransformVect(pParticle->Pos) : pParticle->Pos);
		for(int i=0; i<6; ++i)
		{
			pVertices[current+i].Pos = transform.TransformVect(pVertices[current+i].Pos);
			pVertices[current+i].color = Color::Create(m_ParticleColor.R, m_ParticleColor.G, m_ParticleColor.B, pParticle->Alpha);
		}
		return 6;
	}
Esempio n. 29
0
Dvoid Camera::Yaw()
{
    if (m_MouseMoveInterval.x == 0)
        return;

    m_bMove = true;

    Matrix44	matRot;
    Vector3	vUp(0, 1, 0);
    float	fAngle = m_MouseMoveInterval.x * m_fMouseSens * m_fTimeDelta;

    matRot.Rotation(vUp, fAngle);

    for (Duint i = 0; i < CD_MAX; ++i)
    {
        m_vDir[i] = Vec4ToVec3(matRot * Vector4(m_vDir[i], 0), Vector4::W_IGNORE);
        m_vDir[i].Normalize();
    }
}
Esempio n. 30
0
void cStage_IngameEnd::Update(const float elapseTime)
{
	graphic::cCharacter* pMe = m_user == 1 ? character1 : character2;

//	if( m_camDirOriginal.DotProduct(pMe->GetCamera()->GetDirection()) < 1 )
//		pMe->GetCamera()-

	if( m_nextStage )
	{
		m_tick += elapseTime;

		if( m_tick >= 5.f )
		{
			m_tick = 0.f;
			GetStageMgr()->SetStage( GetStageMgr()->ENDING );
			GetStageMgr()->GetStage()->Init();
		}
	}

//	bool bAniState1 = character1->Move(elapseTime);
//	bool bAniState2 = character2->Move(elapseTime);
	bool bAniState = pMe->Move(elapseTime);

//	if( bAniState1 == false && bAniState2 == false )
	if( bAniState == false )
	{
		m_nextStage = true;

//		character1->GetBoneMgr()->SetAniLoop(true);
//		character1->SetAnimation( "..\\media\\ani\\valle\\valle1_normal.ani" );
//		character2->GetBoneMgr()->SetAniLoop(true);
//		character2->SetAnimation( "..\\media\\ani\\valle\\valle1_normal.ani" );
		pMe->GetBoneMgr()->SetAniLoop(true);
		pMe->SetAnimation( "..\\media\\ani\\valle\\valle1_normal.ani" );

		Matrix44 matR;
		matR.SetRotationY( MATH_PI );
//		character1->SetTM( matR * character1->GetTM() );
//		character2->SetTM( matR * character2->GetTM() );
		pMe->SetTM( matR * pMe->GetTM() );
	}
}