C++ 对象旋转/平移后重新计算AABB correct_C++_Opengl_Collision Detection_Physics Engine_Aabb

C++ 对象旋转/平移后重新计算AABB correct

c++ opengl

C++ 对象旋转/平移后重新计算AABB correct,c++,opengl,collision-detection,physics-engine,aabb,C++,Opengl,Collision Detection,Physics Engine,Aabb,我在这里看到过这个主题，但它并没有真正帮助我解决这个问题：（我尝试以同样的方式实现代码，但有些东西工作不正常。不幸的是，我不能使用glLoadIdentity（），因为我使用的是libqglviewer，并且由于一些奇怪的原因，如果我使用glLoadIdentity（）对象（常规多维数据集）消失：（因此，我的解决方法是每次必须平移/旋转对象时，使用glPopMatrix和glPushMatrix保持世界矩阵的完整性。原始矩阵被存储起来，然后在平移/旋转完成后，我再次将其弹出到目前为止，这一切都

我在这里看到过这个主题，但它并没有真正帮助我解决这个问题：（我尝试以同样的方式实现代码，但有些东西工作不正常。不幸的是，我不能使用glLoadIdentity（），因为我使用的是libqglviewer，并且由于一些奇怪的原因，如果我使用glLoadIdentity（）对象（常规多维数据集）消失：（因此，我的解决方法是每次必须平移/旋转对象时，使用glPopMatrix和glPushMatrix保持世界矩阵的完整性。原始矩阵被存储起来，然后在平移/旋转完成后，我再次将其弹出

到目前为止，这一切都很好，但一旦我尝试重新计算边界框，我的框就会从与立方体相同的位置开始，但一旦我开始旋转它，边界框有时会“内爆”因此，我需要检查“最大/最小”角，这样它们就不会比立方体本身小，但当我旋转相机时，边界框会移动到一边或另一边

我正在使用GLM加载模型，不幸的是，遗留OpenGL，我对遗留OGL的工作原理有点熟悉，但我认为在重新计算边界框时，边界框的计算不正确

此代码位于我的渲染函数中：

glPushMatrix();
  glTranslatef(position.x, position.y, position.z);
  glRotatef(m_angle, m_torque.x, m_torque.y, m_torque.z);
  glGetFloatv(GL_MODELVIEW_MATRIX, mvMatrix);
  glmDraw(pModelCube, GLM_SMOOTH); // Renders the object
glPopMatrix();

glPushMatrix();
  glTranslatef(position.x, position.y, position.z);
  bb->RecalculateBox(pModelCube, mvMatrix, BBid);
  bb->DrawBox(bb->GetBoundingBox(BBid)); 
glPopMatrix();

这是我设置边界框的代码：

void AABB::initBox(BoundingBox* b)
{
    b->min.x = 10000.0f;
    b->min.y = 10000.0f;
    b->min.z = 10000.0f;

    b->max.x = -10000.0f;
    b->max.y = -10000.0f;
    b->max.z = -10000.0f;
}

BoundingBox* AABB::CreateCollisionBox(GLMmodel* model, GLMgroup* object)
{
    BoundingBox* box = (BoundingBox*)malloc(sizeof(BoundingBox));
    initBox(box);

    for(int i = 0; i < object->numtriangles; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            GLuint index = model->triangles[object->triangles[i]].vindices[j];
            GLfloat x = model->vertices[index*3 + 0];
            GLfloat y = model->vertices[index*3 + 1];
            GLfloat z = model->vertices[index*3 + 2];

            if(box->min.x > x) box->min.x = x;
            if(box->min.y > y) box->min.y = y;
            if(box->min.z > z) box->min.z = z;

            if(box->max.x < x) box->max.x = x;
            if(box->max.y < y) box->max.y = y;
            if(box->max.z < z) box->max.z = z;
        }
    }

    return box;
}

void AABB::DrawBox(BoundingBox* b)
{
    if(collision)
    {
        // Sets color to red
        glColor3f(1.0f, 0.0f, 0.0f);
    }
    else
    {
        // Sets color to yellow
        glColor3f(1.0f, 1.0f, 0.0f);
    }

    glBegin(GL_LINE_LOOP);
    glVertex3f(b->max.x, b->max.y, b->min.z);
    glVertex3f(b->min.x, b->max.y, b->min.z);
    glVertex3f(b->min.x, b->min.y, b->min.z);
    glVertex3f(b->max.x, b->min.y, b->min.z);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex3f(b->max.x, b->min.y, b->max.z);
    glVertex3f(b->max.x, b->max.y, b->max.z);
    glVertex3f(b->min.x, b->max.y, b->max.z);
    glVertex3f(b->min.x, b->min.y, b->max.z);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex3f(b->max.x, b->max.y, b->min.z);
    glVertex3f(b->max.x, b->max.y, b->max.z);
    glVertex3f(b->min.x, b->max.y, b->max.z);
    glVertex3f(b->min.x, b->max.y, b->min.z);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex3f(b->max.x, b->min.y, b->max.z);
    glVertex3f(b->min.x, b->min.y, b->max.z);
    glVertex3f(b->min.x, b->min.y, b->min.z);
    glVertex3f(b->max.z, b->min.y, b->min.z);
    glEnd();
}

void AABB:：initBox（BoundingBox*b）
{
b->min.x=10000.0f；
b->最小y=10000.0f；
b->min.z=10000.0f；
b->max.x=-10000.0f；
b->max.y=-10000.0f；
b->max.z=-10000.0f；
}
BoundingBox*AABB:：CreateCollisionBox（GLMmodel*模型，GLMgroup*对象）
{
BoundingBox*box=（BoundingBox*）malloc（sizeof（BoundingBox））；
initBox（box）；
对于（int i=0；inumtriangles；i++）
{
对于（int j=0；j<3；j++）
{
GLuint index=model->triangles[object->triangles[i]].vindices[j]；
GLfloat x=模型->顶点[索引*3+0]；
GLfloat y=模型->顶点[索引*3+1]；
GLfloat z=模型->顶点[索引*3+2]；
如果（box->min.x>x）box->min.x=x；
如果（框->最小y>y）框->最小y=y；
如果（box->min.z>z）box->min.z=z；
如果（框->最大x最大x=x；
如果（框->最大y最大y=y；
如果（长方体->最大z最大z=z；
}
}
返回框；
}
void AABB:：绘图框（边界框*b）
{
如果（碰撞）
{
//将颜色设置为红色
GL3F（1.0f，0.0f，0.0f）；
}
其他的
{
//将颜色设置为黄色
GL3F（1.0f，1.0f，0.0f）；
}
glBegin（GL_线_环）；
glVertex3f（b->max.x，b->max.y，b->min.z）；
glVertex3f（b->min.x，b->max.y，b->min.z）；
glVertex3f（b->min.x，b->min.y，b->min.z）；
glVertex3f（b->max.x，b->min.y，b->min.z）；
格伦德（）；
glBegin（GL_线_环）；
glVertex3f（b->max.x，b->min.y，b->max.z）；
glVertex3f（b->max.x，b->max.y，b->max.z）；
glVertex3f（b->min.x，b->max.y，b->max.z）；
glVertex3f（b->min.x，b->min.y，b->max.z）；
格伦德（）；
glBegin（GL_线_环）；
glVertex3f（b->max.x，b->max.y，b->min.z）；
glVertex3f（b->max.x，b->max.y，b->max.z）；
glVertex3f（b->min.x，b->max.y，b->max.z）；
glVertex3f（b->min.x，b->max.y，b->min.z）；
格伦德（）；
glBegin（GL_线_环）；
glVertex3f（b->max.x，b->min.y，b->max.z）；
glVertex3f（b->min.x，b->min.y，b->max.z）；
glVertex3f（b->min.x，b->min.y，b->min.z）；
glVertex3f（b->max.z，b->min.y，b->min.z）；
格伦德（）；
}

最后一块是我重新计算方框的地方：

void AABB::RecalculateBox(GLMmodel* model, float matrix[16], int &id)
{
    BoundingBox* box = boxes[id]/*(BoundingBox*)malloc(sizeof(BoundingBox))*/;
    initBox(box);
    float   dimensions[3];

    // This will get the absolute dimensions of the object
    glmDimensions(model, dimensions);

    box->max.x = dimensions[0] / 2.0f, box->min.x = -1.0f * box->max.x;
    box->max.y = dimensions[1] / 2.0f, box->min.y = -1.0f * box->max.y;
    box->max.z = dimensions[2] / 2.0f; box->min.z = -1.0f * box->max.z;

    box->max.x = matrix[0] * box->max.x + matrix[4] * box->max.y + matrix[8] * box->max.z + matrix[12];
    box->max.y = matrix[1] * box->max.x + matrix[5] * box->max.y + matrix[9] * box->max.z + matrix[13];
    box->max.z = matrix[2] * box->max.x + matrix[6] * box->max.y + matrix[10] * box->max.z + matrix[14];
    box->min.x = matrix[0] * box->min.x + matrix[4] * box->min.y + matrix[8] * box->min.z + matrix[12];
    box->min.y = matrix[1] * box->min.x + matrix[5] * box->min.y + matrix[9] * box->min.z + matrix[13];
    box->min.z = matrix[2] * box->min.x + matrix[6] * box->min.y + matrix[10] * box->min.z + matrix[14];

    box->bounds[0] = Vec(box->max.x, box->max.y, box->min.z);
    box->bounds[1] = Vec(box->min.x, box->max.y, box->min.z);
    box->bounds[2] = Vec(box->min.x, box->min.y, box->min.z);
    box->bounds[3] = Vec(box->max.x, box->min.y, box->min.z);
    box->bounds[4] = Vec(box->max.x, box->min.y, box->max.z);
    box->bounds[5] = Vec(box->max.x, box->max.y, box->max.z);
    box->bounds[6] = Vec(box->min.x, box->max.y, box->max.z);
    box->bounds[7] = Vec(box->min.x, box->min.y, box->max.z);

    //This code below is from how my bounding box was calculated before.
    /*for(int i = 0; i < object->numtriangles; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            GLuint index = model->triangles[object->triangles[i]].vindices[j];
            GLfloat x = model->vertices[index*3 + 0];
            GLfloat y = model->vertices[index*3 + 1];
            GLfloat z = model->vertices[index*3 + 2];

            if(box->min.x > x) box->min.x = x;
            if(box->min.y > y) box->min.y = y;
            if(box->min.z > z) box->min.z = z;

            if(box->max.x < x) box->max.x = x;
            if(box->max.y < y) box->max.y = y;
            if(box->max.z < z) box->max.z = z;
        }
    }*/

    boxes[id] = box;
}

void AABB:：重新计算ebox（GLMmodel*模型，浮点矩阵[16]，int&id）
{
BoundingBox*box=box[id]/*（BoundingBox*）malloc（sizeof（BoundingBox））*/；
initBox（box）；
浮动尺寸[3]；
//这将获得对象的绝对尺寸
GLM尺寸（型号、尺寸）；
box->max.x=尺寸[0]/2.0f，box->min.x=-1.0f*box->max.x；
长方体->最大y=尺寸[1]/2.0f，长方体->最小y=-1.0f*长方体->最大y；
box->max.z=尺寸[2]/2.0f；box->min.z=-1.0f*box->max.z；
box->max.x=矩阵[0]*box->max.x+矩阵[4]*box->max.y+矩阵[8]*box->max.z+矩阵[12]；
box->max.y=matrix[1]*box->max.x+matrix[5]*box->max.y+matrix[9]*box->max.z+matrix[13]；
box->max.z=矩阵[2]*box->max.x+矩阵[6]*box->max.y+矩阵[10]*box->max.z+矩阵[14]；
box->min.x=矩阵[0]*box->min.x+矩阵[4]*box->min.y+矩阵[8]*box->min.z+矩阵[12]；
box->min.y=矩阵[1]*box->min.x+矩阵[5]*box->min.y+矩阵[9]*box->min.z+矩阵[13]；
box->min.z=矩阵[2]*box->min.x+矩阵[6]*box->min.y+矩阵[10]*box->min.z+矩阵[14]；
框->边界[0]=Vec（框->最大x，框->最大y，框->最小z）；
框->边界[1]=Vec（框->最小x，框->最大y，框->最小z）；
框->边界[2]=Vec（框->最小x，框->最小y，框->最小z）；
框->边界[3]=Vec（框->最大x，框->最小y，框->最小z）；
框->边界[4]=Vec（框->最大x，框->最小y，框->最大z）；
box->bounds[5]=Vec（box->max.x，box->max.y，box->max.z）；
框->边界[6]=Vec（框->最小x，框->最大y，框->最大z）；
框->边界[7]=Vec（框->最小x，框->最小y，框->最大z）；
//下面的代码来自于我的边界框以前是如何计算的。
/*对于（int i=0；inumtriangles；i++）
{
对于（int j=0；j<3；j++）
{
GLuint index=model->triangles[object->triangles[i]].vindices[j]；
GLfloat x=模型->顶点[索引*3+0]；
GLfloat y=模型->顶点[索引*3+1]；
GLfloat z=模型->顶点[索引*3+2]；
如果（box->min.x>x）box->min.x=x；
如果（框->最小y>y）框->最小y=y；
如果（box->min.z>z）box->min.z=z；
如果（框->最大x最大x=x；
如果（框->最大y最大y=y；
如果（长方体->最大z最大z=z；
}
}*/
box[id]=box；
}

我一直在努力