how to draw 3d cube in opengl visual studio

I presume that you have some knowledge of OpenGL. Otherwise, read "Introduction to OpenGL with 2D Graphics".

Example i: 3D Shapes (OGL01Shape3D.cpp)

This example is taken from Nehe OpenGL Tutorial Lesson # five (@ http://nehe.gamedev.net/), which displays a 3D color-cube and a pyramid. The cube is made of of vi quads, each having different colors. The hallow pyramid is fabricated upwardly of 4 triangle, with different colors on each of the vertices.

ane 2 3 4 five 6 vii eight nine 10 11 12 13 xiv 15 16 17 18 xix 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 forty 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 threescore 61 62 63 64 65 66 67 68 69 lxx 71 72 73 74 75 76 77 78 79 eighty 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

#include <windows.h> #include <GL/glut.h> char title[] = "3D Shapes"; void initGL() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClearDepth(i.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glShadeModel(GL_SMOOTH); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); } void brandish() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(one.5f, 0.0f, -7.0f); glBegin(GL_QUADS); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, -ane.0f); glVertex3f(-1.0f, one.0f, -one.0f); glVertex3f(-one.0f, 1.0f, ane.0f); glVertex3f( i.0f, i.0f, 1.0f); glColor3f(one.0f, 0.5f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glVertex3f(-one.0f, -1.0f, -1.0f); glVertex3f( one.0f, -1.0f, -one.0f); glColor3f(i.0f, 0.0f, 0.0f); glVertex3f( 1.0f, one.0f, 1.0f); glVertex3f(-ane.0f, 1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glVertex3f( 1.0f, -1.0f, 1.0f); glColor3f(one.0f, one.0f, 0.0f); glVertex3f( i.0f, -1.0f, -ane.0f); glVertex3f(-1.0f, -one.0f, -i.0f); glVertex3f(-1.0f, one.0f, -1.0f); glVertex3f( ane.0f, 1.0f, -1.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, one.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glVertex3f(-1.0f, -one.0f, -1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glColor3f(1.0f, 0.0f, 1.0f); glVertex3f(1.0f, ane.0f, -i.0f); glVertex3f(i.0f, i.0f, 1.0f); glVertex3f(ane.0f, -i.0f, 1.0f); glVertex3f(one.0f, -1.0f, -1.0f); glEnd(); glLoadIdentity(); glTranslatef(-1.5f, 0.0f, -6.0f); glBegin(GL_TRIANGLES); glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f, i.0f, 0.0f); glColor3f(0.0f, ane.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(1.0f, -1.0f, 1.0f); glColor3f(i.0f, 0.0f, 0.0f); glVertex3f(0.0f, ane.0f, 0.0f); glColor3f(0.0f, 0.0f, one.0f); glVertex3f(1.0f, -1.0f, 1.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(1.0f, -ane.0f, -one.0f); glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, ane.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); glColor3f(0.0f, 0.0f, one.0f); glVertex3f(-ane.0f, -1.0f, -1.0f); glColor3f(1.0f,0.0f,0.0f); glVertex3f( 0.0f, 1.0f, 0.0f); glColor3f(0.0f,0.0f,1.0f); glVertex3f(-1.0f,-1.0f,-one.0f); glColor3f(0.0f,1.0f,0.0f); glVertex3f(-one.0f,-1.0f, i.0f); glEnd(); glutSwapBuffers(); } void reshape(GLsizei width, GLsizei pinnacle) { if (pinnacle == 0) peak = ane; GLfloat aspect = (GLfloat)width / (GLfloat)summit; glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f, aspect, 0.1f, 100.0f); } int chief(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE); glutInitWindowSize(640, 480); glutInitWindowPosition(50, 50); glutCreateWindow(title); glutDisplayFunc(display); glutReshapeFunc(reshape); initGL(); glutMainLoop(); return 0; }

Glut Setup - chief()

The plan contains a initGL(), display() and reshape() functions.

The primary() program:

1. glutInit(&argc, argv);
   Initializes the GLUT.
2. glutInitWindowSize(640, 480);
   glutInitWindowPosition(50, l);
   glutCreateWindow(title);
   Creates a window with a title, initial width and height positioned at initial peak-left corner.
3. glutDisplayFunc(display);
   Registers brandish() as the re-paint event handler. That is, the graphics sub-arrangement calls back display() when the window get-go appears and whenever there is a re-paint asking.
4. glutReshapeFunc(reshape);
   Registers reshape() as the re-sized event handler. That is, the graphics sub-system calls dorsum reshape() when the window first appears and whenever the window is re-sized.
5. glutInitDisplayMode(GLUT_DOUBLE);
   Enables double buffering. In display(), we use glutSwapBuffers() to signal to the GPU to swap the front-buffer and back-buffer during the next VSync (Vertical Synchronization).
6. initGL();
   Invokes the initGL() one time to perform all onetime initialization tasks.
7. glutMainLoop();
   Finally, enters the upshot-processing loop.

One-Time Initialization Operations - initGL()

The initGL() function performs the erstwhile initialization tasks. It is invoked from main() one time (and only one time).

glClearColor(0.0f, 0.0f, 0.0f, one.0f);
glClearDepth(1.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Fix the clearing (groundwork) colour to blackness (R=0, G=0, B=0) and opaque (A=ane), and the clearing (groundwork) depth to the farthest (Z=one). In display(), we invoke glClear() to clear the color and depth buffer, with the immigration color and depth, before rendering the graphics. (Also the color buffer and depth buffer, OpenGL likewise maintains an accumulation buffer and a stencil buffer which shall be discussed afterwards.)

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
Nosotros need to enable depth-exam to remove the subconscious surface, and prepare the function used for the depth examination.

glShadeModel(GL_SMOOTH);
We enable smooth shading in color transition. The alternative is GL_FLAT. Effort information technology out and come across the difference.

glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
In graphics rendering, there is oft a trade-off between processing speed and visual quality. We can use glHint() to decide on the trade-off. In this case, we ask for the best perspective correction, which may involve more processing. The default is GL_DONT_CARE.

Defining the Color-cube and Pyramid

OpenGL'south object is fabricated up of primitives (such as triangle, quad, polygon, point and line). A primitive is defined via one or more vertices. The color-cube is made upwards of half dozen quads. Each quad is fabricated up of 4 vertices, divers in counter-clockwise (CCW) order, such as the normal vector is pointing out, indicating the front end face. All the iv vertices have the same color. The colour-cube is defined in its local space (called model space) with origin at the eye of the cube with sides of ii units.

Similarly, the pyramid is made up of 4 triangles (without the base). Each triangle is made up of iii vertices, defined in CCW social club. The v vertices of the pyramid are assigned different colors. The color of the triangles are interpolated (and alloy smoothly) from its iii vertices. Again, the pyramid is defined in its local space with origin at the center of the pyramid.

Model Transform

The objects are defined in their local spaces (model spaces). We need to transform them to the common globe space, known every bit model transform.

To perform model transform, we need to operate on the then-called model-view matrix (OpenGL has a few transformation matrices), by setting the current matrix mode to model-view matrix:

glMatrixMode(GL_MODELVIEW);

Nosotros perform translations on cube and pyramid, respectively, to position them on the globe space:

glLoadIdentity();
glTranslatef(one.5f, 0.0f, -vii.0f);

glLoadIdentity();
glTranslatef(-1.5f, 0.0f, -6.0f);

View Transform

The default camera position is:

gluLookAt(0.0, 0.0, 0.0, 0.0, 0.0, -100.0, 0.0, i.0, 0.0)

That is, EYE=(0,0,0) at the origin, AT=(0,0,-100) pointing at negative-z centrality (into the screen), and Upward=(0,1,0) corresponds to y-centrality.

OpenGL graphics rendering pipeline performs so-called view transform to bring the world space to camera's view space. In the case of the default camera position, no transform is needed.

Viewport Transform

void reshape(GLsizei width, GLsizei pinnacle) {
glViewport(0, 0, width, superlative);
The graphics sub-organization calls dorsum reshape() when the window first appears and whenever the window is resized, given the new window's width and height, in pixels. We gear up our application viewport to cover the entire window, top-left corner at (0, 0) of width and acme, with default minZ of 0 and maxZ of 1. Nosotros likewise employ the aforementioned attribute ratio of the viewport for the projection view frustum to prevent baloney. In the viewport, a pixel has (x, y) value as well every bit z-value for depth processing.

Projection Transform

GLfloat aspect = (GLfloat)width / (GLfloat)top;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, attribute, 0.1f, 100.0f);
A camera has limited field of view. The projection models the view captured by the camera. There are ii types of projection: perspective project and orthographic project. In perspective projection, object farther to the photographic camera appears smaller compared with object of the same size nearer to the photographic camera. In orthographic project, the objects appear the same regardless of the z-value. Orthographic projection is a special case of perspective projection where the camera is placed very far away. We shall hash out the orthographic project in the subsequently instance.

To gear up the projection, we demand to operate on the project matrix. (Recall that we operated on the model-view matrix in model transform.)

We set up the matrix mode to projection matrix and reset the matrix. We utilise the gluPerspective() to enable perspective projection, and prepare the fovy (view angle from the bottom-plane to the top-aeroplane), attribute ratio (width/pinnacle), zNear and zFar of the View Frustum (truncated pyramid). In this example, we gear up the fovy to 45°. We utilise the same aspect ratio as the viewport to avoid distortion. We set the zNear to 0.ane and zFar to 100 (z=-100). Accept that note the color-cube (1.5, 0, -7) and the pyramid (-1.5, 0, -half dozen) are independent within the View Frustum.

The projection transform transforms the view frustum to a 2x2x1 cuboid clipping-volume centered on the nigh plane (z=0). The subsequent viewport transform transforms the clipping-volume to the viewport in screen space. The viewport is gear up earlier via the glViewport() function.

Example two: 3D Shape with Animation (OGL02Animation.cpp)

Allow's modify the previous case to carry out blitheness (rotating the cube and pyramid).

1 two 3 iv 5 6 7 eight 9 ten eleven 12 13 14 xv 16 17 eighteen 19 xx 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 twoscore 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 sixty 61 62 63 64 65 66 67 68 69 lxx 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 ninety 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161

#include <windows.h> #include <GL/overabundance.h> char title[] = "3D Shapes with animation"; GLfloat anglePyramid = 0.0f; GLfloat angleCube = 0.0f; int refreshMills = fifteen; void initGL() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glShadeModel(GL_SMOOTH); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); } void brandish() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(i.5f, 0.0f, -seven.0f); glRotatef(angleCube, 1.0f, one.0f, 1.0f); glBegin(GL_QUADS); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, -one.0f); glVertex3f(-1.0f, ane.0f, -i.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glVertex3f( i.0f, 1.0f, one.0f); glColor3f(i.0f, 0.5f, 0.0f); glVertex3f( 1.0f, -1.0f, i.0f); glVertex3f(-ane.0f, -1.0f, 1.0f); glVertex3f(-1.0f, -one.0f, -i.0f); glVertex3f( 1.0f, -i.0f, -1.0f); glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 1.0f, ane.0f, 1.0f); glVertex3f(-1.0f, i.0f, 1.0f); glVertex3f(-ane.0f, -ane.0f, i.0f); glVertex3f( ane.0f, -ane.0f, 1.0f); glColor3f(1.0f, one.0f, 0.0f); glVertex3f( 1.0f, -one.0f, -1.0f); glVertex3f(-1.0f, -1.0f, -one.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glVertex3f( 1.0f, 1.0f, -ane.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, ane.0f, one.0f); glVertex3f(-1.0f, 1.0f, -i.0f); glVertex3f(-1.0f, -1.0f, -ane.0f); glVertex3f(-1.0f, -one.0f, 1.0f); glColor3f(1.0f, 0.0f, 1.0f); glVertex3f(1.0f, 1.0f, -one.0f); glVertex3f(i.0f, ane.0f, 1.0f); glVertex3f(1.0f, -one.0f, 1.0f); glVertex3f(i.0f, -1.0f, -1.0f); glEnd(); glLoadIdentity(); glTranslatef(-1.5f, 0.0f, -6.0f); glRotatef(anglePyramid, 1.0f, 1.0f, 0.0f); glBegin(GL_TRIANGLES); glColor3f(i.0f, 0.0f, 0.0f); glVertex3f( 0.0f, one.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(ane.0f, -i.0f, one.0f); glColor3f(i.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(i.0f, -1.0f, 1.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(one.0f, -1.0f, -1.0f); glColor3f(one.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); glColor3f(i.0f,0.0f,0.0f); glVertex3f( 0.0f, 1.0f, 0.0f); glColor3f(0.0f,0.0f,ane.0f); glVertex3f(-ane.0f,-1.0f,-1.0f); glColor3f(0.0f,1.0f,0.0f); glVertex3f(-1.0f,-i.0f, 1.0f); glEnd(); glutSwapBuffers(); anglePyramid += 0.2f; angleCube -= 0.15f; } void timer(int value) { glutPostRedisplay(); glutTimerFunc(refreshMills, timer, 0); } void reshape(GLsizei width, GLsizei elevation) { if (height == 0) height = 1; GLfloat aspect = (GLfloat)width / (GLfloat)meridian; glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f, aspect, 0.1f, 100.0f); } int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE); glutInitWindowSize(640, 480); glutInitWindowPosition(l, 50); glutCreateWindow(title); glutDisplayFunc(brandish); glutReshapeFunc(reshape); initGL(); glutTimerFunc(0, timer, 0); glutMainLoop(); return 0; }

The new codes are:

GLfloat anglePyramid = 0.0f;
GLfloat angleCube = 0.0f;
int refreshMills = fifteen;
Nosotros ascertain two global variables to keep track of the current rotational angles of the cube and pyramid. We as well define the refresh menses as 15 msec (66 frames per 2nd).

void timer(int value) {
glutPostRedisplay();
glutTimerFunc(refreshMills, timer, 0); //
}
To perform blitheness, we define a part called timer(), which posts a re-paint request to activate display() when the timer expired, and so run the timer once more. In main(), we perform the commencement timer() call via glutTimerFunc(0, timer, 0).

glRotatef(angleCube, ane.0f, 1.0f, 1.0f);
......
glRotatef(anglePyramid, 1.0f, ane.0f, 0.0f);
......
anglePyramid += 0.2f;
angleCube -= 0.15f;
In display(), we rotate the cube and pyramid based on their rotational angles, and update the angles subsequently each refresh.

Case 3: Orthographic Projection (OGL03Orthographic.cpp)

As mentioned, OpenGL support two type of projections: perspective and orthographic. In orthographic projection, an object appears to exist the same size regardless of the depth. Orthographic is a special case of perspective projection, where the camera is placed very far away.

To use orthographic projection, alter the reshape() function to invoke glOrtho().

void reshape(GLsizei width, GLsizei acme) {          if (acme == 0) height = 1;                    GLfloat aspect = (GLfloat)width / (GLfloat)height;          glViewport(0, 0, width, tiptop);          glMatrixMode(GL_PROJECTION);      glLoadIdentity();                                   if (width >= height) {             glOrtho(-3.0 * attribute, 3.0 * aspect, -3.0, three.0, 0.1, 100);    } else {             glOrtho(-3.0, three.0, -iii.0 / aspect, three.0 / attribute, 0.one, 100);    }          }

In this example, we set the cross-department of view-volume according to the attribute ratio of the viewport, and depth from 0.1 to 100, respective to z=-0.1 to z=-100. Take note that the cube and pyramid are independent within the view-volume.

Instance 4: Vertex Array

In the before example, drawing a cube requires at to the lowest degree 24 glVertex functions and a pair of glBegin and glEnd. Function calls may involve high overhead and hinder the performance. Furthermore, each vertex is specified and candy three times.

Link to OpenGL/Calculator Graphics References and Resource

lauderdalenatithem.blogspot.com

Source: https://www3.ntu.edu.sg/home/ehchua/programming/opengl/CG_Examples.html

Share this post