C++ BoundingSphere::getRadius方法代码示例

 bool BoundingEllipsoid::intersects(BoundingSphere &bs, CollisionResultSet::Info& info) {
     //We do the same for check the collision with a circle, except taht the circle have only 1 ray.
     //The equation for the circle is then a bit different.
     math::Ray r(bs.getCenter(), center);
     math::Vec3f near, far;
     if (!intersectsWhere(r, near, far, info))
         return false;
     math::Vec3f d = far - center;
     return (center.computeDistSquared(bs.getCenter()) - bs.getRadius() * bs.getRadius() - d.magnSquared()) <= 0;
 }

bool OpenGLRenderer::renderBoundingSphere(const BoundingSphere &sphere, const glm::vec3 &center, const glm::vec3 &color, Camera &camera,
                                          RenderTarget &renderTarget)
{
    /* Calculate MVP matrix, bounding box coordinates are already in world coordinates */
    glm::mat4 MVP = camera.getPerspectiveMatrix() * camera.getViewMatrix();

    /* Bind the render target */
    renderTarget.bind();
    {
        GLuint boxPosVAO, boxPosVBO;

        __(glEnable(GL_DEPTH_TEST));

        //__(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
        //__(glEnable(GL_CULL_FACE));

        /* Bind program to upload the uniform */
        _renderBoundingSphere.attach();

        /* Send our transformation to the currently bound _renderBoundingSpheres, in the "MVP" uniform */
        _renderBoundingSphere.setUniformMat4("u_MVPMatrix", &MVP);
        _renderBoundingSphere.setUniformMat4("u_projectionMatrix", &camera.getPerspectiveMatrix());
        _renderBoundingSphere.setUniformVec3("u_boxColor", const_cast<glm::vec3 &>(color));
        _renderBoundingSphere.setUniformFloat("u_radius", sphere.getRadius());

        __(glGenVertexArrays(1, &boxPosVAO));
        __(glBindVertexArray(boxPosVAO));

        __(glGenBuffers(1, &boxPosVBO));

        __(glBindBuffer(GL_ARRAY_BUFFER, boxPosVBO));

        __(glBufferData(GL_ARRAY_BUFFER, sizeof center, &center[0], GL_STATIC_DRAW));

        __(glEnableVertexAttribArray(0));
        __(glVertexAttribPointer(0,  // attribute. No particular reason for 0, but must match the layout in the _renderBoundingSpheres.
                                 3,  // size
                                 GL_FLOAT,  // type
                                 GL_FALSE,  // normalized?
                                 0,         // stride
                                 (void *)0  // array buffer offset
                                 ));

        __(glDrawArrays(GL_POINTS, 0, 1));

        __(glBindVertexArray(0));

        __(glDeleteBuffers(1, &boxPosVBO));
        __(glDeleteVertexArrays(1, &boxPosVAO));

        /* Unbind */
        _renderBoundingSphere.detach();
    }
    renderTarget.unbind();

    return true;
}

		Bounds::Ptr expand(const BoundingSphere &bounds) const {
			BoundingSphere::Desc desc;
			desc.pose = bounds.getPose();
			desc.radius = bounds.getRadius() + skinThickness;
			return desc.create();
		}