#include <stdlib.h>#include <stdio.h>#include <string.h>#include "MyOpenGLExtensions.h"/* Ensure we are using opengl's core profile only *///#define GL3_PROTOTYPES 1//#include <GL3/gl3.h>#include <gl\gl.h>#include<gl\glext.h>#include <SDL\SDL.h>#include <math.h>#include "utils.h"void setupwindow(SDL_WindowID *window, SDL_GLContext *context){	if (SDL_Init(SDL_INIT_VIDEO) < 0) /* Initialize SDL's Video subsystem */		sdldie("Unable to initialize SDL"); /* Or die on error */	/* Request an opengl 3.2 context.	 * SDL doesn't have the ability to choose which profile at this time of writing,	 * but it should default to the core profile */	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);	/* Enable double buffering with a 24bit Z buffer.	 * You may need to change this to 16 or 32 for your system */	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);	/* Enable multisampling for a nice antialiased effect */	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);	/* Create our window centered at 512x512 resolution */	*window = SDL_CreateWindow("Tutorial 4", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,		512, 512, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);	if (!*window) /* Die if creation failed */		sdldie("Unable to create window");	/* Create our opengl context and attach it to our window */	*context = SDL_GL_CreateContext(*window);	if (initGLExtensions() == false)	{		sdldie("Unable to load openGL extensions");	}	/* This makes our buffer swap syncronized with the monitor's vertical refresh */	SDL_GL_SetSwapInterval(1);    /* Enable Z depth testing so objects closest to the viewpoint are in front of objects further away */    glEnable(GL_DEPTH_TEST);    glDepthFunc(GL_LESS);}void drawscene(SDL_WindowID window){    int i; /* Simple iterator */    GLuint vao, vbo[3]; /* Create handles for our Vertex Array Object and three Vertex Buffer Objects */    GLfloat projectionmatrix[16]; /* Our projection matrix starts with all 0s */    GLfloat modelmatrix[16]; /* Our model matrix  */    /* An identity matrix we use to perform the equivalant of glLoadIdentity */    const GLfloat identitymatrix[16] = IDENTITY_MATRIX4;     /* The four vericies of a tetrahedron */    const GLfloat tetrahedron[4][3] = {    {  1.0,  1.0,  1.0  },   /* index 0 */     { -1.0, -1.0,  1.0  },   /* index 1 */    { -1.0,  1.0, -1.0  },   /* index 2 */    {  1.0, -1.0, -1.0  } }; /* index 3 */    /* Color information for each vertex */    const GLfloat colors[4][3] = {    {  1.0,  0.0,  0.0  },   /* red */    {  0.0,  1.0,  0.0  },   /* green */    {  0.0,  0.0,  1.0  },   /* blue */    {  1.0,  1.0,  1.0  } }; /* white */    const GLubyte tetraindicies[6] = { 0, 1, 2, 3, 0, 1 };    /* These pointers will receive the contents of our shader source code files */    GLchar *vertexsource, *fragmentsource, *geometrysource;    /* These are handles used to reference the shaders */    GLuint vertexshader, fragmentshader, geometryshader;    /* This is a handle to the shader program */    GLuint shaderprogram;	/* Allocate and assign a Vertex Array Object to our handle */	glGenVertexArrays(1, &vao);    /* Bind our Vertex Array Object as the current used object */	glBindVertexArray(vao);    /* Allocate and assign three Vertex Buffer Objects to our handle */    glGenBuffers(3, vbo);    /* Bind our first VBO as being the active buffer and storing vertex attributes (coordinates) */    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);    /* Copy the vertex data from tetrahedron to our buffer */    /* 12 * sizeof(GLfloat) is the size of the tetrahedrom array, since it contains 12 GLfloat values */    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), tetrahedron, GL_STATIC_DRAW);        /* Specify that our coordinate data is going into attribute index 0, and contains three floats per vertex */    glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0);    /* Enable attribute index 0 as being used */    glEnableVertexAttribArray(0);    /* Bind our second VBO as being the active buffer and storing vertex attributes (colors) */    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);    /* Copy the color data from colors to our buffer */    /* 12 * sizeof(GLfloat) is the size of the colors array, since it contains 12 GLfloat values */    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), colors, GL_STATIC_DRAW);    /* Specify that our color data is going into attribute index 1, and contains three floats per vertex */    glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, 0, 0);    /* Enable attribute index 1 as being used */    glEnableVertexAttribArray(1);        /* Bind our third VBO as being the active buffer and storing vertex array indicies */    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[2]);    /* Copy the index data from tetraindicies to our buffer     * 6 * sizeof(GLubyte) is the size of the index array, since it contains 6 GLbyte values */    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLubyte), tetraindicies, GL_STATIC_DRAW);    /* Read our shaders into the appropriate buffers */	vertexsource = filetobuf("tutorial4.vert");	geometrysource = filetobuf("tutorial4.geom");    fragmentsource = filetobuf("tutorial4.frag");    /* Assign our handles a "name" to new shader objects */	vertexshader = glCreateShader(GL_VERTEX_SHADER);    geometryshader = glCreateShader(GL_GEOMETRY_SHADER);    fragmentshader = glCreateShader(GL_FRAGMENT_SHADER);    /* Associate the source code buffers with each handle */	glShaderSource(vertexshader, 1, (const GLchar**)&vertexsource, 0);	glShaderSource(geometryshader, 1, (const GLchar**)&geometrysource, 0);    glShaderSource(fragmentshader, 1, (const GLchar**)&fragmentsource, 0);    /* Compile our shader objects */    glCompileShader(vertexshader);    glCompileShader(geometryshader);    glCompileShader(fragmentshader);    /* Assign our program handle a "name" */    shaderprogram = glCreateProgram();        /* Attach our shaders to our program */    glAttachShader(shaderprogram, vertexshader);    glAttachShader(shaderprogram, geometryshader);    glAttachShader(shaderprogram, fragmentshader);        /* Bind attribute 0 (coordinates) to in_Position and attribute 1 (colors) to in_Color */    glBindAttribLocation(shaderprogram, 0, "in_Position");    glBindAttribLocation(shaderprogram, 1, "in_Color");    /* Link our program, and set it as being actively used */    glLinkProgram(shaderprogram);    glUseProgram(shaderprogram);    /* Create our projection matrix with a 45 degree field of view     * a width to height ratio of 1 and view from .1 to 100 infront of us */    perspective(projectionmatrix, 45.0, 1.0, 0.1, 100.0);    /* Loop our display rotating our model more each time. */    for (i=0; i < 360; i++)    {        /* Load the identity matrix into modelmatrix. rotate the model, and move it back 5 */        memcpy(modelmatrix, identitymatrix, sizeof(GLfloat) * 16);		rotate(modelmatrix, (GLfloat)i * -1.0, X_AXIS);        rotate(modelmatrix, (GLfloat)i * 1.0, Y_AXIS);        rotate(modelmatrix, (GLfloat)i * 0.5, Z_AXIS);        translate(modelmatrix, 0, 0, -5.0);        /* multiply our modelmatrix and our projectionmatrix. Results are stored in modelmatrix */        multiply4x4(modelmatrix, projectionmatrix);        /* Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram */        glUniformMatrix4fv(glGetUniformLocation(shaderprogram, "mvpmatrix"), 1, GL_FALSE, modelmatrix);        /* Make our background black */        glClearColor(0.0, 0.0, 0.0, 1.0);        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);        /* Invoke glDrawElements telling it to draw a triangle strip using 6 indicies */        glDrawElements(GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_BYTE, 0);        /* Swap our buffers to make our changes visible */        SDL_GL_SwapWindow(window);        /* Sleep for roughly 33 milliseconds between frames */        //SDL_Delay(33);    }    /* Cleanup all the things we bound and allocated */    glUseProgram(0);    glDisableVertexAttribArray(0);    glDisableVertexAttribArray(1);    glDetachShader(shaderprogram, vertexshader);    glDetachShader(shaderprogram, geometryshader);    glDetachShader(shaderprogram, fragmentshader);    glDeleteProgram(shaderprogram);    glDeleteShader(vertexshader);    glDeleteShader(geometryshader);    glDeleteShader(fragmentshader);	glDeleteBuffers(3, vbo);    glDeleteVertexArrays(1, &vao);    free(vertexsource);    free(geometrysource);    free(fragmentsource);}void destroywindow(SDL_WindowID window, SDL_GLContext context){    SDL_GL_DeleteContext(context);    SDL_DestroyWindow(window);    SDL_Quit();}/* Our program's entry point */int main(int argc, char *argv[]){    SDL_WindowID mainwindow; /* Our window handle */    SDL_GLContext maincontext; /* Our opengl context handle */    /* Create our window, opengl context, etc... */    setupwindow(&mainwindow, &maincontext);    /* Call our function that performs opengl operations */	drawscene(mainwindow);    /* Delete our opengl context, destroy our window, and shutdown SDL */    destroywindow(mainwindow, maincontext);	return 0;}

//---------------------------------------------------------------------------#ifndef MyOpenGLExtensionsH#define MyOpenGLExtensionsH#ifndef GLHEADERS#define GLHEADERS#include <windows.h>#include <gl\gl.h>#include <gl\glext.h>#endif//int initGLExtensions();	//function prototypePFNGLCREATESHADERPROC glCreateShader;PFNGLSHADERSOURCEPROC glShaderSource;PFNGLCOMPILESHADERPROC glCompileShader;...PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;int initGLExtensions(){glCreateShader = (PFNGLCREATESHADERPROC) wglGetProcAddress("glCreateShader");glShaderSource = (PFNGLSHADERSOURCEPROC) wglGetProcAddress("glShaderSource");glCompileShader = (PFNGLCOMPILESHADERPROC) wglGetProcAddress("glCompileShader");glCreateProgram = (PFNGLCREATEPROGRAMPROC) wglGetProcAddress("glCreateProgram");...glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) wglGetProcAddress("glDeleteVertexArrays");glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) wglGetProcAddress("glUniformMatrix4fv");if(glGenVertexArrays == NULL)	{		int x =0;	}if (glCreateShader == NULL || glShaderSource == NULL || glCompileShader == NULL        || glCreateProgram == NULL || glAttachShader == NULL || glLinkProgram == NULL        || glUseProgram==NULL || glGetShaderiv == NULL || glDetachShader == NULL        || glDeleteShader == NULL || glDeleteProgram == NULL || glIsShader == NULL        || glIsProgram == NULL || glGetUniformLocation == NULL || glUniform1f == NULL		|| glUniform1i == NULL		)		{		return 0;		}else if(glGenBuffers == NULL || glGenFramebuffers == NULL || glBindBuffer == NULL || glBindFramebuffer == NULL		||  glGenRenderbuffers == NULL || glBindRenderbuffer == NULL || glRenderbufferStorage == NULL		|| glFramebufferTexture2D == NULL || glFramebufferRenderbuffer == NULL || glCheckFramebufferStatus  == NULL		|| glDeleteFramebuffers == NULL|| glDeleteRenderbuffers == NULL || glActiveTexture == NULL		|| glBufferData == NULL || glDrawBuffers == NULL || glDeleteBuffers == NULL		)		{		return 0;		}else if(glVertexAttribPointer == NULL || glEnableVertexAttribArray == NULL || glDisableVertexAttribArray == NULL		|| glBindAttribLocation == NULL || glClampColor == NULL || glMultiTexCoord2f == NULL		|| glGenVertexArrays == NULL || glBindVertexArray==NULL || glDeleteVertexArrays==NULL)		{		return 0;		}else if(glUniformMatrix4fv == NULL)		{		return 0;        }return 1;}#endif

#pragma hdrstop#include <stdio.h>#include <stdlib.h>#include <string.h>#define GL3_PROTOTYPES 1#include <GL3/gl3.h>#include <SDL/SDL.h>#include <math.h>#include "utils.h"/* Multiply 4x4 matrix m1 by 4x4 matrix m2 and store the result in m1 */void multiply4x4(GLfloat *m1, GLfloat *m2){    GLfloat temp[16];    int x,y;    for (x=0; x < 4; x++)    {        for(y=0; y < 4; y++)        {            temp[y + (x*4)] = (m1[x*4] * m2[y]) +                              (m1[(x*4)+1] * m2[y+4]) +                              (m1[(x*4)+2] * m2[y+8]) +                              (m1[(x*4)+3] * m2[y+12]);        }    }    memcpy(m1, temp, sizeof(GLfloat) * 16);}/* Generate a perspective view matrix using a field of view angle fov, * window aspect ratio, near and far clipping planes */void perspective(GLfloat *matrix, GLfloat fov, GLfloat aspect, GLfloat nearz, GLfloat farz){    GLfloat range;    range = tan(fov * 0.00872664625) * nearz; /* 0.00872664625 = PI/360 */    memset(matrix, 0, sizeof(GLfloat) * 16);    matrix[0] = (2 * nearz) / ((range * aspect) - (-range * aspect));    matrix[5] = (2 * nearz) / (2 * range);    matrix[10] = -(farz + nearz) / (farz - nearz);    matrix[11] = -1;    matrix[14] = -(2 * farz * nearz) / (farz - nearz);}/* Perform translation operations on a matrix */void translate(GLfloat *matrix, GLfloat x, GLfloat y, GLfloat z){    GLfloat newmatrix[16] = IDENTITY_MATRIX4;    newmatrix[12] = x;    newmatrix[13] = y;    newmatrix[14] = z;    multiply4x4(matrix, newmatrix);}/* Rotate a matrix by an angle on a X, Y, or Z axis */void rotate(GLfloat *matrix, GLfloat angle, AXIS axis){    const GLfloat d2r = 0.0174532925199; /* PI / 180 */    const int cos1[3] = { 5, 0, 0 };    const int cos2[3] = { 10, 10, 5 };    const int sin1[3] = { 6, 2, 1 };    const int sin2[3] = { 9, 8, 4 };    GLfloat newmatrix[16] = IDENTITY_MATRIX4;    newmatrix[cos1[axis]] = cos(d2r * angle);    newmatrix[sin1[axis]] = -sin(d2r * angle);    newmatrix[sin2[axis]] = -newmatrix[sin1[axis]];    newmatrix[cos2[axis]] = newmatrix[cos1[axis]];    multiply4x4(matrix, newmatrix);}/* A simple function that will read a file into an allocated char pointer buffer */char* filetobuf(char *file){    FILE *fptr;    long length;    char *buf;    fptr = fopen(file, "r"); /* Open file for reading */    if (!fptr) /* Return NULL on failure */        return NULL;    fseek(fptr, 0, SEEK_END); /* Seek to the end of the file */    length = ftell(fptr); /* Find out how many bytes into the file we are */    buf = (char*)malloc(length + 1); /* Allocate a buffer for the entire length of the file plus a null terminator */    fseek(fptr, 0, SEEK_SET); /* Go back to the beginning of the file */    fread(buf, length, 1, fptr); /* Read the contents of the file in to the buffer */    fclose(fptr); /* Close the file */    buf[length] = 0; /* Null terminator */    return buf; /* Return the buffer */}/* A simple function that prints a message, the error code returned by SDL, and quits the application */void sdldie(char *msg){    printf("%s: %s\n", msg, SDL_GetError());    SDL_Quit();    exit(1);}