示例#1
0
// mirror coordinate system will change the handedness of original coordinate system
//
// axis_mirror: defines the axis that coordinate system mirror on
//
Mat3 mirror_coordinate_system (CoordinateAxisType axis_mirror)
{
    Mat3 t_mat;

    switch (axis_mirror) {
    case AXIS_X:
    case AXIS_MINUS_X:
        t_mat = Mat3(Vec3(-1, 0, 0),
                     Vec3(0, 1, 0),
                     Vec3(0, 0, 1));
        break;
    case AXIS_Y:
    case AXIS_MINUS_Y:
        t_mat = Mat3(Vec3(1, 0, 0),
                    Vec3(0, -1, 0),
                    Vec3(0, 0, 1));
        break;
    case AXIS_Z:
    case AXIS_MINUS_Z:
        t_mat = Mat3(Vec3(1, 0, 0),
                    Vec3(0, 1, 0),
                    Vec3(0, 0, -1));
        break;
    default:
        t_mat = Mat3();
        break;
    }

    return t_mat;
}
示例#2
0
	void TrackballCameraController::Track(float x,float y)
	{

	// 
	// 	Mat4 mat(1.0);
	// 	mat = glm::rotate(mat,y*mRotationScaler,mRight); 
	// 	mat = glm::rotate(mat,x*mRotationScaler,Vec3(0.0f, glm::dot(mCamera->UpVec(), Vec3(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f));
	// 	Vec3 pos    = (mCamera->Eye())*Mat3(mat);
	// 	Vec3 target = mCamera->Tareget()*Mat3(mat);
	// 	Vec3     up = Vec3(0.0f, glm::dot(mCamera->UpVec(), Vec3(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f);
	// 	mRight = glm::normalize(glm::cross(up, -pos));
	// 	mCamera->LookAt(pos, target, mCamera->UpVec());

		/*Quat q = MathLib::rotation_axis(mRight, y * mRotationScaler);
		Mat4 mat = MathLib::transformation(mTarget, q);
		Vec3 pos = MathLib::transform_coord(mCamera->Eye(), mat);

		q = MathLib::rotation_axis(Vec3(0.0f, glm::dot(mCamera->UpVec(), Vec3(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f), x * mRotationScaler);
		mat = MathLib::transformation(mTarget, q);
		pos = MathLib::transform_coord(pos, mat);

		mRight = MathLib::transform_quat(mRight, q);

		Vec3 dir;
		if (mReverseTarget)
		{
			dir = pos - mTarget;
		}
		else
		{
			dir = mTarget - pos;
		}
		dir = glm::normalize(dir);
		Vec3 up = glm::cross(dir, mRight);

		mCamera->LookAt(pos, pos + dir, up);*/

	
		Mat4 mat,matx,maty;
		mat = matx = maty = Mat4(1.0);
		matx = glm::rotate(matx,x*mRotationScaler,Vec3(0,1,0));
		maty = glm::rotate(matx,y*mRotationScaler,Vec3(1,0,0));
		mat = matx*maty;
		Vec3 pos    = (mCamera->Eye())*Mat3(mat);
		Vec3 target = mCamera->Tareget()*Mat3(mat);
		Vec3 up = mCamera->UpVec()*Mat3(mat);
		//Vec3 up = Vec3(0.0f, glm::dot(mCamera->UpVec(), Vec3(0, 1, 0)) < 0 ? -1.0f : 1.0f, 0.0f);
		//mRight = glm::normalize(glm::cross(up, -pos));
		mCamera->LookAt(pos, target,up);
	}
示例#3
0
 Mat3< T > Mat3< T >::operator -(const Mat3& m) const {
      return Mat3(
         e_[X0] - m.e_[X0], e_[Y0] - m.e_[Y0], e_[W0] - m.e_[W0],
         e_[X1] - m.e_[X1], e_[Y1] - m.e_[Y1], e_[W1] - m.e_[W1],
         e_[X2] - m.e_[X2], e_[Y2] - m.e_[Y2], e_[W2] - m.e_[W2]
     );
 }
示例#4
0
 Mat3< T > Mat3< T >::operator *(const T t) const {
      return Mat3(
         e_[X0] * t, e_[Y0] * t, e_[W0] * t,
         e_[X1] * t, e_[Y1] * t, e_[W1] * t,
         e_[X2] * t, e_[Y2] * t, e_[W2] * t
     );
 }
示例#5
0
 Mat3< T > Mat3< T >::getTranspose() const {
     return Mat3(
         e_[X0], e_[X1], e_[X2],
         e_[Y0], e_[Y1], e_[Y2],
         e_[W0], e_[W1], e_[W2]
     );
 }
Mat3 Mat3::Transpose() const
{
	return Mat3(
		m[0], m[1], m[2],
		m[3], m[4], m[5],
		m[6], m[7], m[8] );
}
示例#7
0
		bool GetShot(Shot* shot, Vec3 poi, Vec3 momentum)
		{
			if(blood_material != NULL)
				for (int i = 0; i < 8; ++i)
				{
					Particle* p = new Particle(corpse->game_state, poi, Random3D::RandomNormalizedVector(Random3D::Rand(5)) + momentum * Random3D::Rand(), NULL, blood_material, Random3D::Rand(0.05f, 0.15f), 0.25f);
					p->gravity = 9.8f;
					p->damp = 0.05f;

					corpse->game_state->Spawn(p);
				}

			Mat4 xform;
			{
				xform = rbi->GetTransformationMatrix();
				float ori_values[] = {xform[0], xform[1], xform[2], xform[4], xform[5], xform[6], xform[8], xform[9], xform[10]};
				Quaternion rigid_body_ori = Quaternion::FromRotationMatrix(Mat3(ori_values).Transpose());
				Vec3 pos = xform.TransformVec3(0, 0, 0, 1);
				xform = Mat4::FromPositionAndOrientation(pos, rigid_body_ori.ToMat3().Transpose());
			}

			Vec3 pos = xform.TransformVec3(0, 0, 0, 1);
			Vec3 x_axis = xform.TransformVec3(1, 0, 0, 0);
			Vec3 y_axis = xform.TransformVec3(0, 1, 0, 0);
			Vec3 z_axis = xform.TransformVec3(0, 0, 1, 0);

			Vec3 local_poi;
			local_poi = poi - pos;
			local_poi = Vec3(Vec3::Dot(local_poi, x_axis), Vec3::Dot(local_poi, y_axis), Vec3::Dot(local_poi, z_axis));
			local_poi = local_poi.x * x_axis + local_poi.y * y_axis + local_poi.z * z_axis;

			rbi->Activate();
			rbi->ApplyImpulse(momentum, local_poi);
			return true;
		}
示例#8
0
文件: Vec3.cpp 项目: BrigadierBaz/NGL
Mat3 Vec3::outer(const Vec3 &_v  )  const
{
  return Mat3(
              m_x * _v.m_x, m_x * _v.m_y, m_x * _v.m_z,
              m_y * _v.m_x, m_y * _v.m_y, m_y * _v.m_z,
              m_z * _v.m_x, m_z * _v.m_y, m_z * _v.m_z
            );
}
示例#9
0
// rotate coordinate system keeps the handedness of original coordinate system unchanged
//
// axis_to_x: defines the axis of the new cooridinate system that
//    coincide with the X axis of the original coordinate system.
// axis_to_y: defines the axis of the new cooridinate system that
//    coincide with the Y axis of the original coordinate system.
//
Mat3 rotate_coordinate_system (CoordinateAxisType axis_to_x, CoordinateAxisType axis_to_y)
{
    Mat3 t_mat;
    if (axis_to_x == AXIS_X && axis_to_y == AXIS_MINUS_Z) {
        t_mat = Mat3(Vec3(1, 0, 0),
                     Vec3(0, 0, 1),
                     Vec3(0, -1, 0));
    } else if (axis_to_x == AXIS_X && axis_to_y == AXIS_MINUS_Y) {
        t_mat = Mat3(Vec3(1, 0, 0),
                     Vec3(0, -1, 0),
                     Vec3(0, 0, -1));
    } else if (axis_to_x == AXIS_X && axis_to_y == AXIS_Z) {
        t_mat = Mat3(Vec3(1, 0, 0),
                     Vec3(0, 0, -1),
                     Vec3(0, 1, 0));
    } else if (axis_to_x == AXIS_MINUS_Z && axis_to_y == AXIS_Y) {
        t_mat = Mat3(Vec3(0, 0, 1),
                    Vec3(0, 1, 0),
                     Vec3(-1, 0, 0));
    } else if (axis_to_x == AXIS_MINUS_X && axis_to_y == AXIS_Y) {
        t_mat = Mat3(Vec3(-1, 0, 0),
                     Vec3(0, 1, 0),
                     Vec3(0, 0, -1));
    } else if (axis_to_x == AXIS_Z && axis_to_y == AXIS_Y) {
        t_mat = Mat3(Vec3(0, 0, -1),
                     Vec3(0, 1, 0),
                     Vec3(1, 0, 0));
    } else if (axis_to_x == AXIS_MINUS_Y && axis_to_y == AXIS_X) {
        t_mat = Mat3(Vec3(0, 1, 0),
                    Vec3(-1, 0, 0),
                     Vec3(0, 0, 1));
    } else if (axis_to_x == AXIS_MINUS_X && axis_to_y == AXIS_MINUS_Y) {
        t_mat = Mat3(Vec3(-1, 0, 0),
                     Vec3(0, -1, 0),
                     Vec3(0, 0, 1));
    } else if (axis_to_x == AXIS_Y && axis_to_y == AXIS_MINUS_X) {
        t_mat = Mat3(Vec3(0, -1, 0),
                     Vec3(1, 0, 0),
                     Vec3(0, 0, 1));
    } else  {
        t_mat = Mat3();
    }
    return t_mat;
}
示例#10
0
    Mat3< T > Mat3< T >::getIdentity() {
        const T n = static_cast< T >(0.0);
        const T u = static_cast< T >(1.0);

        return Mat3(
            u, n, n,
            n, u, n,
            n, n, u
        );
    }
示例#11
0
    Mat3< T > Mat3<T>::getTranslation(const T x, const T y) {
        const T n = static_cast< T >(0.0);
        const T u = static_cast< T >(1.0);

        return Mat3(
            u, n, n,
            n, u, n,
            x, y, u
        );
    }
示例#12
0
    Mat3< T > Mat3<T>::getScaling(const T x, const T y) {
        const T n = static_cast< T >(0.0);
        const T u = static_cast< T >(1.0);

        return Mat3(
            x, n, n,
            n, y, n,
            n, n, u
        );
    }
示例#13
0
void StageLayer::Render(Renderer *renderer)
{
    // render
    if(!isVisible())
        return;
    renderer->setStageLayer(this);
    this->setViewport();
    this->visit(renderer, Mat3(), false);
    renderer->Flush();
}
示例#14
0
	void Rubbish::Update(TimingInfo time)
	{
		xform = rigid_body->GetTransformationMatrix();

		float ori_values[] = {xform[0], xform[1], xform[2], xform[4], xform[5], xform[6], xform[8], xform[9], xform[10]};
		Quaternion rigid_body_ori = Quaternion::FromRotationMatrix(Mat3(ori_values).Transpose());

		Vec3 pos = xform.TransformVec3(0, 0, 0, 1);

		xform = Mat4::FromPositionAndOrientation(pos, rigid_body_ori.ToMat3().Transpose());
	}
示例#15
0
Mat3 Mat3::rotate(const float &theta)
{
#if defined RADIANS
	float cosT = cosf(theta);				   //  theta in radians
	float sinT = sinf(theta);				   //  theta in radians
#elif defined DEGREES
	float cosT = cosf(theta * M_PI / 180.0f);   //  theta in degrees
	float sinT = sinf(theta * M_PI / 180.0f);   //  theta in degrees
#endif

#if defined RIGHTHANDED
	return Mat3( cosT, -sinT, 0.0f,
				 sinT,  cosT, 0.0f,
				 0.0f,  0.0f, 1.0f);
#elif defined LEFTHANDED
	return Mat3( cosT, sinT, 0.0f,
				-sinT, cosT, 0.0f,
				 0.0f, 0.0f, 1.0f);
#endif
}
示例#16
0
Mat3 Mat3::operator*(const Mat3 &m) const
{
	return Mat3( d00*m.d00 + d01*m.d10 + d02*m.d20,
				 d00*m.d01 + d01*m.d11 + d02*m.d21,
				 d00*m.d02 + d01*m.d12 + d02*m.d22,
				 d10*m.d00 + d11*m.d10 + d12*m.d20,
				 d10*m.d01 + d11*m.d11 + d12*m.d21,
				 d10*m.d02 + d11*m.d12 + d12*m.d22,
				 d20*m.d00 + d21*m.d10 + d22*m.d20,
				 d20*m.d01 + d21*m.d11 + d22*m.d21,
				 d20*m.d02 + d21*m.d12 + d22*m.d22 );
}
示例#17
0
 Mat3< T > Mat3< T >::operator *(const Mat3& m) const {
     return Mat3(
         e_[X0] * m.e_[X0] + e_[X1] * m.e_[Y0] + e_[X2] * m.e_[W0],
         e_[Y0] * m.e_[X0] + e_[Y1] * m.e_[Y0] + e_[Y2] * m.e_[W0],
         e_[W0] * m.e_[X0] + e_[W1] * m.e_[Y0] + e_[W2] * m.e_[W0],
         e_[X0] * m.e_[X1] + e_[X1] * m.e_[Y1] + e_[X2] * m.e_[W1],
         e_[Y0] * m.e_[X1] + e_[Y1] * m.e_[Y1] + e_[Y2] * m.e_[W1],
         e_[W0] * m.e_[X1] + e_[W1] * m.e_[Y1] + e_[W2] * m.e_[W1],
         e_[X0] * m.e_[X2] + e_[X1] * m.e_[Y2] + e_[X2] * m.e_[W2],
         e_[Y0] * m.e_[X2] + e_[Y1] * m.e_[Y2] + e_[Y2] * m.e_[W2],
         e_[W0] * m.e_[X2] + e_[W1] * m.e_[Y2] + e_[W2] * m.e_[W2]
     );
 }
示例#18
0
Mat3 Mat3::inverse()
{
	return Mat3( d11*d22 - d21*d12,
				-d01*d22 - d21*d02,
				 d01*d12 - d11*d02,
				-d10*d22 - d20*d12,
				 d00*d22 - d20*d02,
				-d00*d12 - d10*d02,
				 d10*d21 - d20*d11,
				-d00*d21 - d20*d01,
				 d00*d11 - d10*d01)
				/determinant();
}
示例#19
0
    Mat3< T > Mat3<T>::getRotation(const T r) {
        const T n = static_cast< T >(0.0);
        const T u = static_cast< T >(1.0);

        const T rad = r * Constants< T >::InvDeg360() * Constants< T >::Pi2();

        const T c = std::cos(rad);
        const T s = std::sin(rad);

        return Mat3(
             c, s, n,
            -s, c, n,
             n, n, u
        );
    }
示例#20
0
    Mat3< T > Mat3< T >::getInverse() const {
        const T invDet = static_cast< T >(1.0) / getDeterminant();

        return Mat3(
            e_[Y1] * e_[W2] - e_[Y2] * e_[W1],
            e_[Y2] * e_[W0] - e_[Y0] * e_[W2],
            e_[Y0] * e_[W1] - e_[Y1] * e_[W0],
            e_[X2] * e_[W1] - e_[X1] * e_[W2],
            e_[X0] * e_[W2] - e_[X2] * e_[W0],
            e_[X1] * e_[W0] - e_[X0] * e_[W1],
            e_[X1] * e_[Y2] - e_[X2] * e_[Y1],
            e_[X2] * e_[Y0] - e_[X0] * e_[Y2],
            e_[X0] * e_[Y1] - e_[X1] * e_[Y0]
        ) * invDet;
    }
示例#21
0
//==============================================================================
void DebugDrawer::drawSphere(F32 radius, I complexity)
{
#if 1
	Mat4 oldMMat = m_mMat;
	Mat4 oldVpMat = m_vpMat;

	setModelMatrix(m_mMat * Mat4(Vec4(0.0, 0.0, 0.0, 1.0),
		Mat3::getIdentity(), radius));

	begin(GL_LINES);

	// Pre-calculate the sphere points5
	F32 fi = getPi<F32>() / complexity;

	Vec3 prev(1.0, 0.0, 0.0);
	for(F32 th = fi; th < getPi<F32>() * 2.0 + fi; th += fi)
	{
		Vec3 p = Mat3(Euler(0.0, th, 0.0)) * Vec3(1.0, 0.0, 0.0);

		for(F32 th2 = 0.0; th2 < getPi<F32>(); th2 += fi)
		{
			Mat3 rot(Euler(th2, 0.0, 0.0));

			Vec3 rotPrev = rot * prev;
			Vec3 rotP = rot * p;

			pushBackVertex(rotPrev);
			pushBackVertex(rotP);

			Mat3 rot2(Euler(0.0, 0.0, getPi<F32>() / 2));

			pushBackVertex(rot2 * rotPrev);
			pushBackVertex(rot2 * rotP);
		}

		prev = p;
	}

	end();

	m_mMat = oldMMat;
	m_vpMat = oldVpMat;
#endif
}
示例#22
0
Mat3 Mat3::lookAt( const Vec3 &look, const Vec3 &up )
{
	/*
	Finally, let s = f x UP', and	u = s x	f.

	    |  s[0]  s[1]   s[2] |
	M = |  u[0]  u[1]   u[2] |
	    | -f[0] -f[1]  -f[2] |
	*/

	const Vec3 f = normalize(look);
	const Vec3 s = cross(f, normalize(up));
	const Vec3 u = cross(s, f);

	Mat3 m = Mat3( s.x,  s.y,  s.z,
	               u.x,  u.y,  u.z,
	              -f.x, -f.y, -f.z);

	return m;
}
示例#23
0
inline Mat3 Mat3::operator -() const
{
	return Mat3(-_11, -_12, -_13,
		        -_21, -_22, -_23,
		        -_31, -_32, -_33);
}
示例#24
0
inline Mat3 Mat3::operator +(const Mat3 & mat) const
{
	return Mat3(_11 + mat._11, _12 + mat._12, _13 + mat._13,
		        _21 + mat._21, _22 + mat._22, _23 + mat._23,
		        _31 + mat._31, _32 + mat._32, _33 + mat._33);
}
示例#25
0
inline Mat3 Mat3::operator -(const Mat3 & mat) const
{
	return Mat3(_11 - mat._11, _12 - mat._12, _13 - mat._13,
		        _21 - mat._21, _22 - mat._22, _23 - mat._23,
		        _31 - mat._31, _32 - mat._32, _33 - mat._33);
}
示例#26
0
Error Dbg::run(RenderingContext& ctx)
{
	ANKI_ASSERT(m_enabled);

	if(!m_initialized)
	{
		ANKI_CHECK(lazyInit());
		m_initialized = true;
	}

	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
	cmdb->beginRenderPass(m_fb);
	cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());

	FrustumComponent& camFrc = *ctx.m_frustumComponent;
	SceneNode& cam = camFrc.getSceneNode();
	m_drawer->prepareFrame(cmdb);
	m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());
	m_drawer->setModelMatrix(Mat4::getIdentity());
	// m_drawer->drawGrid();

	SceneGraph& scene = cam.getSceneGraph();

	SceneDebugDrawer sceneDrawer(m_drawer);
	camFrc.getVisibilityTestResults().iterateAll([&](SceneNode& node) {
		if(&node == &cam)
		{
			return;
		}

		// Set position
		MoveComponent* mv = node.tryGetComponent<MoveComponent>();
		if(mv)
		{
			m_drawer->setModelMatrix(Mat4(mv->getWorldTransform()));
		}
		else
		{
			m_drawer->setModelMatrix(Mat4::getIdentity());
		}

		// Spatial
		if(m_flags.get(DbgFlag::SPATIAL_COMPONENT))
		{
			Error err = node.iterateComponentsOfType<SpatialComponent>([&](SpatialComponent& sp) -> Error {
				sceneDrawer.draw(sp);
				return ErrorCode::NONE;
			});
			(void)err;
		}

		// Frustum
		if(m_flags.get(DbgFlag::FRUSTUM_COMPONENT))
		{
			Error err = node.iterateComponentsOfType<FrustumComponent>([&](FrustumComponent& frc) -> Error {
				if(&frc != &camFrc)
				{
					sceneDrawer.draw(frc);
				}
				return ErrorCode::NONE;
			});
			(void)err;
		}

		// Sector/portal
		if(m_flags.get(DbgFlag::SECTOR_COMPONENT))
		{
			Error err = node.iterateComponentsOfType<SectorComponent>([&](SectorComponent& psc) -> Error {
				sceneDrawer.draw(psc);
				return ErrorCode::NONE;
			});

			err = node.iterateComponentsOfType<PortalComponent>([&](PortalComponent& psc) -> Error {
				sceneDrawer.draw(psc);
				return ErrorCode::NONE;
			});
			(void)err;
		}

		// Decal
		if(m_flags.get(DbgFlag::DECAL_COMPONENT))
		{
			Error err = node.iterateComponentsOfType<DecalComponent>([&](DecalComponent& psc) -> Error {
				sceneDrawer.draw(psc);
				return ErrorCode::NONE;
			});
			(void)err;
		}
	});

	if(m_flags.get(DbgFlag::PHYSICS))
	{
		PhysicsDebugDrawer phyd(m_drawer);

		m_drawer->setModelMatrix(Mat4::getIdentity());
		phyd.drawWorld(scene.getPhysicsWorld());
	}

#if 0
	{
		m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());
		m_drawer->setModelMatrix(Mat4::getIdentity());
		CollisionDebugDrawer cd(m_drawer);
		Mat4 proj = camFrc.getProjectionMatrix();

		m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());

		Sphere s(Vec4(1.2, 2.0, -1.1, 0.0), 2.1);

		s.accept(cd);

		Transform trf = scene.findSceneNode("light0").getComponent<MoveComponent>().getWorldTransform();
		Vec4 rayOrigin = trf.getOrigin();
		Vec3 rayDir = -trf.getRotation().getZAxis().getNormalized();
		m_drawer->setModelMatrix(Mat4::getIdentity());
		m_drawer->drawLine(rayOrigin.xyz(), rayOrigin.xyz() + rayDir.xyz() * 10.0, Vec4(1.0, 1.0, 1.0, 1.0));

		Array<Vec4, 2> intersectionPoints;
		U intersectionPointCount;
		s.intersectsRay(rayDir.xyz0(), rayOrigin, intersectionPoints, intersectionPointCount);
		for(U i = 0; i < intersectionPointCount; ++i)
		{
			m_drawer->drawLine(Vec3(0.0), intersectionPoints[i].xyz(), Vec4(0.0, 1.0, 0.0, 1.0));
		}
	}
#endif

#if 0
	{
		Clusterer c;
		c.init(getAllocator(), 16, 12, 30);

		const FrustumComponent& frc = scene.findSceneNode("cam0").getComponent<FrustumComponent>();
		const MoveComponent& movc = scene.findSceneNode("cam0").getComponent<MoveComponent>();

		ClustererPrepareInfo pinf;
		pinf.m_viewMat = frc.getViewMatrix();
		pinf.m_projMat = frc.getProjectionMatrix();
		pinf.m_camTrf = frc.getFrustum().getTransform();
		c.prepare(m_r->getThreadPool(), pinf);

		class DD : public ClustererDebugDrawer
		{
		public:
			DebugDrawer* m_d;

			void operator()(const Vec3& lineA, const Vec3& lineB, const Vec3& color)
			{
				m_d->drawLine(lineA, lineB, color.xyz1());
			}
		};

		DD dd;
		dd.m_d = m_drawer;

		CollisionDebugDrawer cd(m_drawer);

		Sphere s(Vec4(1.0, 0.1, -1.2, 0.0), 1.2);
		PerspectiveFrustum fr(toRad(25.), toRad(35.), 0.1, 5.);
		fr.transform(Transform(Vec4(0., 1., 0., 0.), Mat3x4::getIdentity(), 1.0));

		m_drawer->setModelMatrix(Mat4(movc.getWorldTransform()));
		// c.debugDraw(dd);

		if(frc.getFrustum().insideFrustum(fr))
		{
			ClustererTestResult rez;
			c.initTestResults(getAllocator(), rez);
			Aabb sbox;
			fr.computeAabb(sbox);
			c.binPerspectiveFrustum(fr, sbox, rez);
			//c.bin(s, sbox, rez);

			c.debugDrawResult(rez, dd);
		}

		m_drawer->setColor(Vec4(1.0, 1.0, 0.0, 1.0));
		frc.getFrustum().accept(cd);
		fr.accept(cd);
	}
#endif

#if 0
	{
		CollisionDebugDrawer cd(m_drawer);

		Array<Vec3, 4> poly;
		poly[0] = Vec3(0.0, 0.0, 0.0);
		poly[1] = Vec3(2.5, 0.0, 0.0);

		Mat4 trf(Vec4(147.392776, -12.132728, 16.607138, 1.0),
			Mat3(Euler(toRad(45.0), toRad(0.0), toRad(120.0))),
			1.0);

		Array<Vec3, 4> polyw;
		polyw[0] = trf.transform(poly[0]);
		polyw[1] = trf.transform(poly[1]);

		m_drawer->setModelMatrix(Mat4::getIdentity());
		m_drawer->drawLine(polyw[0], polyw[1], Vec4(1.0));

		Vec4 p0 = camFrc.getViewMatrix() * polyw[0].xyz1();
		p0.w() = 0.0;
		Vec4 p1 = camFrc.getViewMatrix() * polyw[1].xyz1();
		p1.w() = 0.0;

		Vec4 r = p1 - p0;
		r.normalize();

		Vec4 a = camFrc.getProjectionMatrix() * p0.xyz1();
		a /= a.w();

		Vec4 i;
		if(r.z() > 0)
		{
			// Plane near(Vec4(0, 0, -1, 0), camFrc.getFrustum().getNear() +
			// 0.001);
			// Bool in = near.intersectRay(p0, r * 100000.0, i);
			i.z() = -camFrc.getFrustum().getNear();
			F32 t = (i.z() - p0.z()) / r.z();
			i.x() = p0.x() + t * r.x();
			i.y() = p0.y() + t * r.y();

			i = camFrc.getProjectionMatrix() * i.xyz1();
			i /= i.w();
		}
		else
		{
			i = camFrc.getProjectionMatrix() * (r * 100000.0).xyz1();
			i /= i.w();
		}

		/*r *= 0.01;
		Vec4 b = polyw[0].xyz0() + r;
		b = camFrc.getViewProjectionMatrix() * b.xyz1();
		Vec4 d = b / b.w();*/

		m_drawer->setViewProjectionMatrix(Mat4::getIdentity());
		m_drawer->drawLine(
			Vec3(a.xy(), 0.1), Vec3(i.xy(), 0.1), Vec4(1.0, 0, 0, 1));
	}
#endif

	m_drawer->finishFrame();
	cmdb->endRenderPass();
	return ErrorCode::NONE;
}
示例#27
0
文件: mat3.cpp 项目: 2asoft/xray
Mat3 adjoint(const Mat3& m)
{
    return Mat3(m[1]^m[2],
		m[2]^m[0],
		m[0]^m[1]);
}
示例#28
0
文件: mat3.cpp 项目: 2asoft/xray
Mat3 diag(const Vec3& v)
{
    return Mat3(Vec3(v[0],0,0),  Vec3(0,v[1],0),  Vec3(0,0,v[2]));
}
示例#29
0
文件: mat3.cpp 项目: 2asoft/xray
Mat3 Mat3::I() { return Mat3(Vec3(1,0,0), Vec3(0,1,0), Vec3(0,0,1)); }
示例#30
0
/*    Retrieves the upper 3x3 matrix of a 4x4 transformation matrix.*/
Mat3 upper3x3(const Mat4& m)
{
    return Mat3(m.m00, m.m01, m.m02,
                m.m10, m.m11, m.m12,
                m.m20, m.m21, m.m22);
}