C++ btVector3::x方法代码示例

void DebugDraw::drawLine(const btVector3& from, const btVector3& to, const btVector3& from_color, const btVector3& to_color) {
    sf::Vertex line[] = {
        sf::Vertex(sf::Vector2f(from.x(), from.y()), btToSfColor(from_color)),
        sf::Vertex(sf::Vector2f(to.x(), to.y()), btToSfColor(to_color))
    };
    m_target->draw(line, 2, sf::Lines);
}

	virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& color)
	{
		ScnDebugRenderComponent::pImpl()->drawLine(
			MaVec3d( from.x(), from.y(), from.z() ),
			MaVec3d( to.x(), to.y(), to.z() ),
			RsColour( color.x(), color.y(), color.z(), 1.0f ) );
	}

void BeGraphicsModel::draw( unsigned int current_material, const btTransform& transform, const btVector3& scale )
{
// 	btScalar m[16];
	transform.getOpenGLMatrix(m_matrix);
// 	m_system->matrixPush(GL_MODELVIEW);
	glPushMatrix();

// 	m_system->matrixMult(GL_MODELVIEW, m_matrix);
	m_system->matrixMult(m_matrix);
// 	m_system->matrixLoad(GL_MODELVIEW, m_matrix);
	
// 		m_system->matrixPush(GL_MODELVIEW);
// 		glPushMatrix();

			if ( scale.x() != 1.0f || scale.y() != 1.0f || scale.z() != 1.0f )
				m_system->matrixScale(GL_MODELVIEW, scale.x(), scale.y(), scale.z());
			
			draw(current_material);

// 		glPopMatrix();
// 		m_system->matrixPop(GL_MODELVIEW);

// 	m_system->matrixPop(GL_MODELVIEW);
	glPopMatrix();

	//glEnable(GL_CULL_FACE);
	//glCullFace(GL_BACK);
}

	virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
	{
		elfCollision* collision;

		m_collisionObject = rayResult.m_collisionObject;
		if (normalInWorldSpace)
		{
			m_hitNormalWorld = rayResult.m_hitNormalLocal;
		}
		else
		{
			m_hitNormalWorld = m_collisionObject->getWorldTransform().getBasis()*rayResult.m_hitNormalLocal;
		}
		m_hitPointWorld.setInterpolate3(m_rayFromWorld, m_rayToWorld, rayResult.m_hitFraction);

		collision = elfCreateCollision();

		collision->position.x = m_hitPointWorld.x();
		collision->position.y = m_hitPointWorld.y();
		collision->position.z = m_hitPointWorld.z();
		collision->normal.x = m_hitNormalWorld.x();
		collision->normal.y = m_hitNormalWorld.y();
		collision->normal.z = m_hitNormalWorld.z();
		collision->actor = ((elfPhysicsObject*)((btRigidBody*)m_collisionObject)->getUserPointer())->actor;
		elfIncRef((elfObject*)collision->actor);

		elfAppendListObject(m_list, (elfObject*)collision);

		return rayResult.m_hitFraction;
	}

void gkPhysicsDebug::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
{
    gkDebugger* dbg = m_physics->getScene()->getDebugger();
    if (dbg)
        dbg->drawLine(gkVector3(from.x(), from.y(), from.z()), gkVector3(to.x(), to.y(), to.z()), gkVector3(color.x(), color.y(), color.z()));

}

static inline btVector3 getPrincipalInertia(const btVector3 & p, const btScalar & m)
{
	return m * btVector3(
		p.y() * p.y() + p.z() * p.z(),
		p.x() * p.x() + p.z() * p.z(),
		p.x() * p.x() + p.y() * p.y());
}

void renderSPH()
{
	static const btVector3 activeColor = btVector3(1, 1, 1);
	static const btVector3 inactiveColor = btVector3(.3, .3, .7);
    for(int n = 0; n < fluid->numParticles(); ++n)
    {
        btVector3 p = fluid->getPosition(n);
		btVector3 vel = fluid->getVelocity(n);
		float speed = std::min(1.0f, vel.length() / 1.0f);
		btVector3 color = (1.0f - speed) * inactiveColor + speed * activeColor;

		glPushMatrix();
        
	    glColor3f(color.x(), color.y(), color.z() );
		float xt = (p.getX() - minBound.x()) / (maxBound.x() - minBound.x());
		float yt = (p.getY() - minBound.y()) / (maxBound.y() - minBound.y());
		float zt = (p.getZ() - minBound.z()) / (maxBound.z() - minBound.z());
        glTranslatef(xt*scale.x() + origin.x(), yt*scale.y()  + origin.y(), zt*scale.z() + origin.z());
        glBegin( GL_LINE_LOOP );
        GLUquadricObj *quadric;
        quadric = gluNewQuadric();
        gluQuadricDrawStyle(quadric, GLU_FILL );
        gluSphere( quadric , 1.0f , 8 , 8);
		glGetError();
        gluDeleteQuadric(quadric);
        glEnd();
		glPopMatrix();
    }
}

void DebugDraw::drawAabb(const btVector3 &from, const btVector3 &to, const btVector3 &color) {
    sf::RectangleShape rect(sf::Vector2f(to.x() - from.x(), to.y() - from.y()));
    rect.setPosition(from.x(), from.y());
    rect.setFillColor(sf::Color::Transparent);
    rect.setOutlineColor(btToSfColor(color));
    rect.setOutlineThickness(0.01f);
    m_target->draw(rect);
}

	void drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color) override {
		DebugRenderQueue::addLine(
			Vec3(from.x(), from.y(), from.z()),
			Vec3(to.x(), to.y(), to.z()),
			Vec4(color.x(), color.y(), color.z(), 1.0f)
		);
		
	}

void DebugDraw::drawTriangle(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2, const btVector3 &color, btScalar) {
    sf::Vertex triangle[] = {
        sf::Vertex(sf::Vector2f(v0.x(), v0.y()), btToSfColor(color)),
        sf::Vertex(sf::Vector2f(v1.x(), v1.y()), btToSfColor(color)),
        sf::Vertex(sf::Vector2f(v2.x(), v2.y()), btToSfColor(color))
    };
    m_target->draw(triangle, 3, sf::Triangles);
}

void PhysicsDebugRenderer::drawContactPoint(const btVector3 &PointOnB, const btVector3 &normalOnB, btScalar distance, int lifeTime, const btVector3 &color)
{
	const glm::vec3 center(PointOnB.x(), PointOnB.y(), PointOnB.z());
	const glm::vec3 cubeSize(0.1f, 0.1f, 0.1f);
	const glm::vec3 cubeColor(color.x(), color.y(), color.z());

	DebugRenderer::DrawCube(center, cubeSize, cubeColor);
}

void PhysicsDebugRenderer::drawLine(const btVector3 &from, const btVector3 &to, const btVector3 &color)
{
	const glm::vec3 start(from.x(), from.y(), from.z());
	const glm::vec3 end(to.x(), to.y(), to.z());
	const glm::vec3 lineColor(color.x(), color.y(), color.z());

	DebugRenderer::DrawLine(start, end, lineColor);
}

void glDebugDraw::drawLine(const btVector3 &from, const btVector3 &to, 
            const btVector3 &color)
{
    glColor3f(color.x(), color.y(), color.z());
    glBegin(GL_LINES);
    glVertex3f(from.x(), from.y(), from.z());
    glVertex3f(to.x(), to.y(), to.z());
    glEnd();
}

void PhysicsDebugDrawer::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
{
    // Draw a line with the 'from' position being slightly darker.
    glm::vec3 glmColor = glm::vec3(color.x(), color.y(), color.z());
    lines.positions.push_back(glm::vec3(from.x(), from.y(), from.z()));
    lines.colors.push_back(glmColor * 0.80f);

    lines.positions.push_back(glm::vec3(to.x(), to.y(), to.z()));
    lines.colors.push_back(glmColor);
}

btVector3 btRigidBody::getLocalInertia() const
{

	btVector3 inertiaLocal;
	const btVector3 inertia = m_invInertiaLocal;
	inertiaLocal.setValue(inertia.x() != btScalar(0.0) ? btScalar(1.0) / inertia.x() : btScalar(0.0),
		inertia.y() != btScalar(0.0) ? btScalar(1.0) / inertia.y() : btScalar(0.0),
		inertia.z() != btScalar(0.0) ? btScalar(1.0) / inertia.z() : btScalar(0.0));
	return inertiaLocal;
}