New Coordinates of the vertices after appliying glTranslatef and glRotatef (OpenGL, C++)

Question

First of all, let me tell i am quite new using OpenGL and C++. However, i want to get involved with this two topics.

So let me explain my case, ive been searching how to get the new coordinates of an object after glTrasnlatef and glRotatef were applied. However, i did not find the find info, actually i found some info about java but i am not getting it, as i told you i am working with C++.

I read there is something to deal with the glPushMatrix(); function but idont know how to handle it.

I know that after applying some trnaslation and rotation i am doing changes into the actual matrix.

Finally, the main purpose of this is because ill use those vertices from the rombohedrom and do a lot of translations and rotations, those are going to be needed as well.

So far this is my code (BTW i am working with lines and the vertices of course because i only need those).

i will really appreciate if someone can address me through the right path.

Thanks in advance Alberto

#include <GL/glut.h>
#include <iostream>
#include <cmath>
#include <vector>

using namespace std;

// Global variables
double rotate_y=0; 
double rotate_x=0;

int width = 640;
int height = 640;

#define PI 3.14159265

float theta = 60;
float edgeLength = 1;
float sinThetaOverHypotenuse = (sin((theta*PI)/180))/edgeLength;

vector<vector<float>> coordinates{{0.0, 0.0, 0.0},
{1.0, 0.0, 0.0},

{1.0, 0.0, 0.0},
{1.5, sinThetaOverHypotenuse, 0.0},

{1.5, sinThetaOverHypotenuse, 0.0},
{0.5, sinThetaOverHypotenuse, 0},

{0.5, sinThetaOverHypotenuse, 0},
{0.0, 0.0, 0.0}};

void rhombohedrom()
{
    vector<vector<float>> rotated {};
//    glClearColor(1,1,0,0)
    //  Clear screen and Z-buffer
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    double w = glutGet( GLUT_WINDOW_WIDTH ) / 300.0;
    double h = glutGet( GLUT_WINDOW_HEIGHT ) / 300.0;
    glOrtho( -1 * w, 1 * w, -1 * h, 1 * h, 10, -10);

glMatrixMode( GL_MODELVIEW );

    // Reset transformations
    glLoadIdentity();

    // Rotate when user changes rotate_x and rotate_y
    glRotatef( rotate_x, 1.0, 0.0, 0.0 );
    glRotatef( rotate_y, 0.0, 1.0, 0.0 );
/*
    FACE 0
    FACE 0
    FACE 0
    FACE 0
*/
    // random color side - front
    glBegin(GL_LINE_LOOP);
        glColor3f( 0.7, 0.3, 0.8 );
        for (int i = 0; i < 8; ++i)
        {
            glVertex3f(coordinates[i][0], coordinates[i][1], coordinates[i][2]);
        }
    glEnd();
/*
    FACE 1
    FACE 1
    FACE 1
    FACE 1
*/
    glPushMatrix();
    glTranslatef(0.0,0.0,0.0);
    glRotatef(90.0, 1.0, 0.0, 0.0);
    glBegin(GL_LINE_LOOP);
        glColor3f( 1.0, 1.0, 1.0 );
        for (int i = 0; i < 8; ++i)
        {
            glVertex3f(coordinates[i][0], coordinates[i][1], coordinates[i][2]);
        }        
    glEnd();
    glPopMatrix();

/*
    FACE 2
    FACE 2
    FACE 2
    FACE 2
*/

    glPushMatrix();
    glTranslatef(0.5,0.0,sinThetaOverHypotenuse);
    glBegin(GL_LINE_LOOP);
        glColor3f( 0.5, 0.5, 0.0 );
        for (int i = 0; i < 8; ++i)
        {
            glVertex3f(coordinates[i][0], coordinates[i][1], coordinates[i][2]);
        }        
    glEnd();
    glPopMatrix();

/*
    FACE 3
    FACE 3
    FACE 3
    FACE 3
*/

    glPushMatrix();
    glTranslatef(0.5,sinThetaOverHypotenuse,0.0);
    glRotatef(90.0, 1.0, 0.0, 0.0);
    glBegin(GL_LINE_LOOP);
        glColor3f( 0.5, 0.0, 0.0 );
        for (int i = 0; i < 8; ++i)
        {
            glVertex3f(coordinates[i][0], coordinates[i][1], coordinates[i][2]);
        }        
    glEnd();
    glPopMatrix();

    glFlush();
    glutSwapBuffers();
}

void specialKeys(int key, int x, int y)

{
    //  Right arrow - increase rotation by 5 degree
    if (key == GLUT_KEY_RIGHT)
        rotate_y += 5;
 
    //  Left arrow - decrease rotation by 5 degree
    else if (key == GLUT_KEY_LEFT)
        rotate_y -= 5;
 
    else if (key == GLUT_KEY_UP)
        rotate_x += 5;
 
    else if (key == GLUT_KEY_DOWN)
        rotate_x -= 5;
 
    //  Request display update
    glutPostRedisplay();
}

int main(int argc, char *argv[])
{

    //  Initialize GLUT and process user parameters
    glutInit(&argc,argv);

    glutInitWindowSize(width,height);
    // Position of the window
    glutInitWindowPosition(10,10);

    //  Request double buffered true color window with Z-buffer
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    // Create window
    glutCreateWindow("rhombohedrom");

    //  Enable Z-buffer depth test
    glEnable(GL_DEPTH_TEST);

    // Callback functions
    glutDisplayFunc(rhombohedrom);
    glutSpecialFunc(specialKeys);

    //
    glutMainLoop();
    
    return 0;
} 

Answer 1

First, I want to address some remarks such as:

glPushMatrix() is an old way, try to use the MVP technique which will help you solving your problem. So, you have to write your Vertex Shader and pass the Matrices through what called uniform in OpenGL. Obviously, you have to use new Routines. glPopMatrix() is also an old routine.

I'm happy to answer your further questions if you want to know more about those remarks.

Use Vertex Shader instead of simple calculus using the CPU!

you can change glTranslatef() and glRotatef() by lookAt so you can change the scale, rotation and translation.

Use Vertex Shader instead of using or stressing the CPU by graphic calculus. Even if you have an Intel integrated GPU