No, I see “easy to use” in a 4D dimension (cf. x,y,z,t) 
For example, the “good old method” for to draw a rotated and 3D textured cube :
// This code was created by Jeff Molofee '99 (ported to Linux/GLUT by Richard Campbell '99)
//
// If you've found this code useful, please let me know.
//
// Visit me at www.demonews.com/hosted/nehe
// (email Richard Campbell at [email]ulmont@bellsouth.net[/email])
//
// YLP 31/05/2011 : modify it for only display a cube
#include <GL/glut.h> // Header File For The GLUT Library
#include <GL/gl.h> // Header File For The OpenGL32 Library
#include <GL/glu.h> // Header File For The GLu32 Library
#include <unistd.h> // needed to sleep
#include <stdio.h>
/* ASCII code for the escape key. */
#define ESCAPE 27
/* The number of our GLUT window */
int window;
/* rotation angle for the cube. */
float rcube = 0.0f;
float rcube_step = 0.1f;
/* Texture */
GLuint texid;
int texwidth=16;
int texheight=16;
int texdepth=16;
/*
GLubyte texData[16] =
{
0xFF,0x00,0x00,0xFF, // red
0x00,0xFF,0x00,0xFF, // green
0x00,0x00,0xFF,0xFF, // blue
0xFF,0xFF,0xFF,0xFF // black
};
*/
GLubyte *texData;
void DrawCube()
{
glColor3f(1.0f,1.0f,1.0f);
// draw a cube (6 quadrilaterals)
glBegin(GL_QUADS); // start drawing the cube.
// Front Face
glTexCoord3f(0.0f, 0.0f,1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
glTexCoord3f(1.0f, 0.0f,1.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
glTexCoord3f(0.0f, 1.0f,1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
// Back Face
glTexCoord3f(0.0f, 0.0f,0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
glTexCoord3f(0.0f, 1.0f,0.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,0.0f); glVertex3f( 1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
glTexCoord3f(1.0f, 0.0f,0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad
// Top Face
glTexCoord3f(0.0f, 1.0f,0.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
glTexCoord3f(0.0f, 1.0f,1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Bottom Right Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,0.0f); glVertex3f( 1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
// Bottom Face
glTexCoord3f(0.0f, 0.0f,0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Top Right Of The Texture and Quad
glTexCoord3f(1.0f, 0.0f,0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); // Top Left Of The Texture and Quad
glTexCoord3f(1.0f, 0.0f,1.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
glTexCoord3f(0.0f, 0.0f,1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
// Right face
glTexCoord3f(1.0f, 0.0f,0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,0.0f); glVertex3f( 1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
glTexCoord3f(1.0f, 1.0f,1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
glTexCoord3f(1.0f, 0.0f,1.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
// Left Face
glTexCoord3f(0.0f, 0.0f,0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad
glTexCoord3f(0.0f, 0.0f,1.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
glTexCoord3f(0.0f, 1.0f,1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
glTexCoord3f(0.0f, 1.0f,0.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
glEnd();
// Done Drawing The Cube
}
void InitTexture()
{
int s,t,p;
GLubyte *ptr;
// Create the 3D texture
ptr=(GLubyte *) malloc(texwidth*texheight*texdepth*4);
texData=ptr;
printf("malloc = %x, texData = %x, size=%d
", ptr, texData, texwidth*texheight*texdepth*4);
for(p=0;p<texdepth;p++)
{
// printf("
depth=%d
", p);
for(t=0;t<texheight;t++)
{
// printf("
height=%d ",t);
for(s=0;s<texwidth;s++)
{
// printf(".");
ptr[0]=s*16; // red
ptr[1]=t*16; // green
ptr[2]=p*16; // blue
ptr[3]=0xFF; // alpha
ptr+=4;
}
}
}
glEnable(GL_TEXTURE_3D);
glGenTextures(1,&texid);
glBindTexture(GL_TEXTURE_3D,texid); //Sélectionne ce n°
glTexImage3D (
GL_TEXTURE_3D, //Type : texture 3D
0, //Mipmap : aucun
GL_RGBA, // (red,green,blue,alpha)
texwidth, // Largeur
texheight, // Hauteur
texdepth, // profondeur
0, //Largeur du bord : 0
GL_RGBA, //Format : RGBA
GL_UNSIGNED_BYTE, //Type des couleurs
texData //Addresse de l'image
);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
/* A general OpenGL initialization function. Sets all of the initial parameters. */
void InitGL(int Width, int Height) // We call this right after our OpenGL window is created.
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // This Will Clear The Background Color To Black
glClearDepth(1.0); // Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS); // The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading
glMatrixMode(GL_PROJECTION);
glLoadIdentity(); // Reset The Projection Matrix
gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f); // Calculate The Aspect Ratio Of The Window
glMatrixMode(GL_MODELVIEW);
InitTexture();
}
/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
void ReSizeGLScene(int Width, int Height)
{
if (Height==0) // Prevent A Divide By Zero If The Window Is Too Small
Height=1;
glViewport(0, 0, Width, Height); // Reset The Current Viewport And Perspective Transformation
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
}
/* The main drawing function. */
void DrawGLScene()
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity(); // Reset the transformation matrix.
glTranslatef(0.0f,0.0f,-7.0f); // Move Right 3 Units, and back into the screen 7
glRotatef(rcube,1.0f,1.0f,1.0f); // Rotate The Cube On X, Y, and Z
DrawCube();
rcube += rcube_step; // Decrease The Rotation Variable For The Cube
// swap the buffers to display, since double buffering is used.
glutSwapBuffers();
}
/* The function called whenever a key is pressed. */
void keyPressed(unsigned char key, int x, int y)
{
/* avoid thrashing this call */
usleep(100);
/* If escape is pressed, kill everything. */
if (key == ESCAPE)
{
/* shut down our window */
glutDestroyWindow(window);
/* exit the program...normal termination. */
exit(0);
}
}
int main(int argc, char **argv)
{
/* Initialize GLUT state - glut will take any command line arguments that pertain to it or
X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */
glutInit(&argc, argv);
/* Select type of Display mode:
Double buffer
RGBA color
Alpha components supported
Depth buffered for automatic clipping */
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
/* get a 640 x 480 window */
glutInitWindowSize(640, 480);
/* the window starts at the upper left corner of the screen */
glutInitWindowPosition(0, 0);
/* Open a window */
window = glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99");
/* Register the function to do all our OpenGL drawing. */
glutDisplayFunc(&DrawGLScene);
/* Go fullscreen. This is as soon as possible. */
//glutFullScreen();
/* Even if there are no events, redraw our gl scene. */
glutIdleFunc(&DrawGLScene);
/* Register the function called when our window is resized. */
glutReshapeFunc(&ReSizeGLScene);
/* Register the function called when the keyboard is pressed. */
glutKeyboardFunc(&keyPressed);
/* Initialize our window. */
InitGL(640, 480);
/* Start Event Processing Engine */
glutMainLoop();
return 0; // bug on my code corrected (cf. return 1 before)
}
And the command for to compile it is
gcc cube.cpp -o cube -lGL -lGLU -lglut
=> I think that this is a relatively simple example that can be easily studied/modified/improved by anybody that have a minimal OpenGL API experience
(for example, only change the GL_NEAREST to GL_LINEAR in the two glTexParameteri() calls for a use texture interpolations, this is very simple but the quality of the display is very better with this very little change)
=> think you that the equivalent using the new OpenGL API methods can to be as simple as this to understand for a person that isn’t particulary experimented with OpenGL ?
(if yes, please post the code for that a true comparaison can be make … it’s perhaps more simple with the new method but I have seriously some doubts about this …)
PS : see you a lot of things that are triangulars around you ?
PS2 : personnaly, I see a lot of rectangulars objets around me but any triangular object
