Real-Time Physics Simulation Forum

Code: Select all

void initPhysics()
{
    broadphase = new btDbvtBroadphase();
    collisionConfiguration = new btDefaultCollisionConfiguration();
    dispatcher = new btCollisionDispatcher(collisionConfiguration);
    solver = new btSequentialImpulseConstraintSolver;

    dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
    dynamicsWorld->setGravity(btVector3(0, -10, 0));

    //groundShape = new btStaticPlaneShape(btVector3(0, 1, 0), 1);
    groundShape = new btBoxShape(btVector3(5, 5, 5));
    fallShape = new btBoxShape(btVector3(1, 1, 1));
    //fallShape = new btSphereShape(1);

    // Orientation and Position of Ground
    groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, -3, 0)));
    btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, groundMotionState, groundShape, btVector3(0, 0, 0));
    groundRigidBody = new btRigidBody(groundRigidBodyCI);
    dynamicsWorld->addRigidBody(groundRigidBody);

    // Orientation and Position of Falling body
    fallMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(-1, 5, 0)));
    btScalar mass = 1;
    btVector3 fallInertia(0, 0, 0);
    fallShape->calculateLocalInertia(mass, fallInertia);
    btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, fallMotionState, fallShape, fallInertia);
    fallRigidBody = new btRigidBody(fallRigidBodyCI);
    dynamicsWorld->addRigidBody(fallRigidBody);

    bulletDebugugger.setDebugMode(btIDebugDraw::DBG_DrawWireframe);
    dynamicsWorld->setDebugDrawer(&bulletDebugugger);

}

Code: Select all

#pragma once
#include <LinearMath/btIDebugDraw.h>

class CDebugDraw :
    public btIDebugDraw
{
private:
    int m_debugMode;
public:
    CDebugDraw(void);
    virtual ~CDebugDraw(void);

    struct _LINE {
        btVector3 from;
        btVector3 to;

        _LINE(btVector3 f, btVector3 t) {
            from = f;
            to = t;
        }
    };

    std::vector<_LINE> LINES;

    struct _COLOR {
        btVector3 col;

        _COLOR(btVector3 c) {
            col = c;
        }
    };

    std::vector<_COLOR> COLORS;

    GLuint vao, vbo[2];

    virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& color);

    virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color);

    virtual void reportErrorWarning(const char* warningString);

    virtual void draw3dText(const btVector3& location,const char* textString);

    virtual void setDebugMode(int m_debugMode);

    virtual int getDebugMode() const;

    void doDrawing();
    void cleanDrawing();
};

Code: Select all

void CDebugDraw::drawLine(const btVector3& from,const btVector3& to,const btVector3& color)
{
    LINES.push_back(_LINE(from, to));
    COLORS.push_back(_COLOR(color));
}

void CDebugDraw::doDrawing()
{
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glGenBuffers(2, vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    glBufferData(GL_ARRAY_BUFFER, LINES.size() * sizeof(_LINE), &LINES[0], GL_STATIC_DRAW);
    glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    glBufferData(GL_ARRAY_BUFFER, COLORS.size() * sizeof(_COLOR), &COLORS[0], GL_STATIC_DRAW);
    glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(1);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

}

void CDebugDraw::cleanDrawing()
{
    // delete buffers
    glDeleteBuffers(2, vbo);
    glDeleteBuffers(1, &vao);
}

Code: Select all

// Debug drawing
    glBindVertexArray(bulletDebugugger.vao);
    glDrawArrays(GL_LINES, 0, bulletDebugugger.LINES.size());
    // Clear vectors
    bulletDebugugger.LINES.clear();
    bulletDebugugger.COLORS.clear();

Code: Select all

void CDebugDraw::drawLine(const btVector3& from,const btVector3& to,const btVector3& color)
{
    // Changed these lines 
    /*LINES.push_back(_LINE(from, to));
    COLORS.push_back(_COLOR(color));*/

    // to these
    LINES.push_back(_LINE(vec3(from.getX(), from.getY(), from.getZ()), vec3(to.getX(), to.getY(), to.getZ())));
    COLORS.push_back(_COLOR(vec3(color.getX(), color.getY(), color.getZ())));
}

Code: Select all

++c; // increment counter
if (c == 2)
    {
        // Yes counter is equal to number of bodies, then we have all the vertices for debug drawing, now reset the vectors.
        LINES.clear();
        COLORS.clear();
        c = 0; // reset counter
    }

Code: Select all

glDrawArrays(GL_LINES, 0, bulletDebugugger.LINES.size() * 2); // size * 2 , because I have TWO vertices in my LINES struct.

Code: Select all

// Debug drawing
    /*
    glBindVertexArray(bulletDebugugger.vao);
    glDrawArrays(GL_LINES, 0, bulletDebugugger.LINES.size());*/
    ///////////////////////////
    vector<GLfloat> vertices;
    vector<GLuint> indices;
    unsigned int indexI = 0;
    
    for (vector<CDebugDraw::_LINE>::iterator it = bulletDebugugger.LINES.begin(); it != bulletDebugugger.LINES.end(); it++)
    {
        CDebugDraw::_LINE l = *it;
        
        vertices.push_back(l.from.x);
        vertices.push_back(l.from.y);
        vertices.push_back(l.from.z);

        vertices.push_back(l.to.x);
        vertices.push_back(l.to.y);
        vertices.push_back(l.to.z);
        
        indices.push_back(indexI);
        indices.push_back(indexI + 1);
        indexI += 2;
    }
    glBindVertexArray(bulletDebugugger.vao);
    glDrawElements(GL_LINES, indices.size(), GL_UNSIGNED_INT, (void*)&indices[0]);
    ///////////////////////////

Code: Select all

 struct btLine{
    GLfloat vertices[6];
    btLine(const btVector3& f, const btVector3& t){
      vertices[0] = f.x();
      vertices[1] = f.y();
      vertices[2] = f.z();

      vertices[3] = t.x();
      vertices[4] = t.y();
      vertices[5] = t.z();
    }
  };

Code: Select all

GME::btLine lines(from, to);
  btVector3 result = to - from;
  glm::vec3 colors = {result.x(), result.y(), result.z()};
  colors = glm::normalize(colors);
  GLuint indices[] = {0,1};

  GLuint vao, vbo, ebo;

  glGenVertexArrays(1, &vao);
  glGenBuffers(1, &vbo);
  glGenBuffers(1, &ebo);

  glBindVertexArray(vao);

  //UPLOADING VERTEX
  glBindBuffer(GL_ARRAY_BUFFER, vbo);
  glBufferData(GL_ARRAY_BUFFER,
               sizeof(GLfloat) * 6, lines.vertices, GL_STATIC_DRAW);
  //UPLOADING INDEXES
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER,
               sizeof(GLuint) * 2,
               indices,
               GL_STATIC_DRAW);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
                        sizeof(GLfloat) * 3, (GLvoid*)0);
  glBindVertexArray(0);


  //use program
  material_->use();
  material_->setValue(glm::value_ptr(colors), "ph_objectColor");
  material_->setProjectionMatrix(gmeinstance->getCurrentCamera()->getProjectionMatrix());
  material_->setViewMatrix(gmeinstance->getCurrentCamera()->getViewMatrix());
  //use geometry
  glBindVertexArray(vao);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,ebo);
  glDrawElements(GL_LINES, 2, GL_UNSIGNED_INT, 0);
  glBindVertexArray(0);

  //delete buffers
  glDeleteVertexArrays(1, &vao);
  glDeleteBuffers(1, &vbo);
  glDeleteBuffers(1, &ebo);