--- /dev/null
+#include <string.h>\r
+#define _USE_MATH_DEFINES\r
+#include <math.h>\r
+#include "glmatrix.h"\r
+\r
+#define MMODE_IDX(x) ((x) - GL_MODELVIEW)\r
+#define MAT_STACK_SIZE 32\r
+#define MAT_IDENT {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}\r
+\r
+static int mm_idx = 0;\r
+static float mat_stack[3][MAT_STACK_SIZE][16] = {{MAT_IDENT}, {MAT_IDENT}, {MAT_IDENT}};\r
+static int stack_top[3];\r
+\r
+void gl_matrix_mode(int mm)\r
+{\r
+ mm_idx = MMODE_IDX(mm);\r
+}\r
+\r
+void gl_push_matrix(void)\r
+{\r
+ int top = stack_top[mm_idx];\r
+\r
+ memcpy(mat_stack[mm_idx][top + 1], mat_stack[mm_idx][top], 16 * sizeof(float));\r
+ stack_top[mm_idx]++;\r
+}\r
+\r
+void gl_pop_matrix(void)\r
+{\r
+ stack_top[mm_idx]--;\r
+}\r
+\r
+void gl_load_identity(void)\r
+{\r
+ static const float idmat[] = MAT_IDENT;\r
+ int top = stack_top[mm_idx];\r
+ float *mat = mat_stack[mm_idx][top];\r
+\r
+ memcpy(mat, idmat, sizeof idmat);\r
+}\r
+\r
+void gl_load_matrixf(const float *m)\r
+{\r
+ int top = stack_top[mm_idx];\r
+ float *mat = mat_stack[mm_idx][top];\r
+\r
+ memcpy(mat, m, 16 * sizeof *mat);\r
+}\r
+\r
+#define M4(i, j) ((i << 2) + j)\r
+\r
+void gl_mult_matrixf(const float *m2)\r
+{\r
+ int i, j;\r
+ int top = stack_top[mm_idx];\r
+ float *m1 = mat_stack[mm_idx][top];\r
+ float res[16];\r
+\r
+ for(i=0; i<4; i++) {\r
+ for(j=0; j<4; j++) {\r
+ res[M4(i,j)] = m1[M4(i,0)] * m2[M4(0,j)] +\r
+ m1[M4(i,1)] * m2[M4(1,j)] +\r
+ m1[M4(i,2)] * m2[M4(2,j)] +\r
+ m1[M4(i,3)] * m2[M4(3,j)];\r
+ }\r
+ }\r
+\r
+ memcpy(m1, res, sizeof res);\r
+}\r
+\r
+void gl_translatef(float x, float y, float z)\r
+{\r
+ float mat[] = MAT_IDENT;\r
+\r
+ mat[12] = x;\r
+ mat[13] = y;\r
+ mat[14] = z;\r
+\r
+ gl_mult_matrixf(mat);\r
+}\r
+\r
+void gl_rotatef(float angle, float x, float y, float z)\r
+{\r
+ float mat[] = MAT_IDENT;\r
+\r
+ float angle_rad = (float)M_PI * angle / 180.f;\r
+ float sina = (float)sin(angle_rad);\r
+ float cosa = (float)cos(angle_rad);\r
+ float one_minus_cosa = 1.f - cosa;\r
+ float nxsq = x * x;\r
+ float nysq = y * y;\r
+ float nzsq = z * z;\r
+\r
+ mat[0] = nxsq + (1.f - nxsq) * cosa;\r
+ mat[4] = x * y * one_minus_cosa - z * sina;\r
+ mat[8] = x * z * one_minus_cosa + y * sina;\r
+ mat[1] = x * y * one_minus_cosa + z * sina;\r
+ mat[5] = nysq + (1.f - nysq) * cosa;\r
+ mat[9] = y * z * one_minus_cosa - x * sina;\r
+ mat[2] = x * z * one_minus_cosa - y * sina;\r
+ mat[6] = y * z * one_minus_cosa + x * sina;\r
+ mat[10] = nzsq + (1.f - nzsq) * cosa;\r
+\r
+ gl_mult_matrixf(mat);\r
+}\r
+\r
+void gl_scalef(float x, float y, float z)\r
+{\r
+ float mat[] = MAT_IDENT;\r
+\r
+ mat[0] = x;\r
+ mat[5] = y;\r
+ mat[10] = z;\r
+\r
+ gl_mult_matrixf(mat);\r
+}\r
+\r
+void gl_ortho(float left, float right, float bottom, float top, float near, float far)\r
+{\r
+ float mat[] = MAT_IDENT;\r
+\r
+ float dx = right - left;\r
+ float dy = top - bottom;\r
+ float dz = far - near;\r
+\r
+ float tx = -(right + left) / dx;\r
+ float ty = -(top + bottom) / dy;\r
+ float tz = -(far + near) / dz;\r
+\r
+ float sx = 2.f / dx;\r
+ float sy = 2.f / dy;\r
+ float sz = -2.f / dz;\r
+\r
+ mat[0] = sx;\r
+ mat[5] = sy;\r
+ mat[10] = sz;\r
+ mat[12] = tx;\r
+ mat[13] = ty;\r
+ mat[14] = tz;\r
+\r
+ gl_mult_matrixf(mat);\r
+}\r
+\r
+void gl_frustum(float left, float right, float bottom, float top, float near, float far)\r
+{\r
+ float mat[] = MAT_IDENT;\r
+\r
+ float dx = right - left;\r
+ float dy = top - bottom;\r
+ float dz = far - near;\r
+\r
+ float a = (right + left) / dx;\r
+ float b = (top + bottom) / dy;\r
+ float c = -(far + near) / dz;\r
+ float d = -2.f * far * near / dz;\r
+\r
+ mat[0] = 2.f * near / dx;\r
+ mat[5] = 2.f * near / dy;\r
+ mat[8] = a;\r
+ mat[9] = b;\r
+ mat[10] = c;\r
+ mat[11] = -1.f;\r
+ mat[14] = d;\r
+\r
+ gl_mult_matrixf(mat);\r
+}\r
+\r
+void glu_perspective(float vfov, float aspect, float near, float far)\r
+{\r
+ float vfov_rad = (float)M_PI * vfov / 180.f;\r
+ float x = near * (float)tan(vfov_rad / 2.f);\r
+ gl_frustum(-aspect * x, aspect * x, -x, x, near, far);\r
+}\r
+\r
+float* get_matrix(int mm)\r
+{\r
+ int idx = MMODE_IDX(mm);\r
+ int top = stack_top[idx];\r
+ return mat_stack[idx][top];\r
+}\r
+\r
+\r
+#define M3(i, j) ((i * 3) + j)\r
+static float inv_transpose_result[9];\r
+\r
+float* get_inv_transpose_3x3(int mm)\r
+{\r
+ int idx = MMODE_IDX(mm);\r
+ int top = stack_top[idx];\r
+ float *m1 = mat_stack[idx][top];\r
+ \r
+\r
+ float determinant = +m1[M4(0,0)]*(m1[M4(1,1)]*m1[M4(2,2)]-m1[M4(2,1)]*m1[M4(1,2)])\r
+ -m1[M4(0,1)]*(m1[M4(1,0)]*m1[M4(2,2)]-m1[M4(1,2)]*m1[M4(2,0)])\r
+ +m1[M4(0,2)]*(m1[M4(1,0)]*m1[M4(2,1)]-m1[M4(1,1)]*m1[M4(2,0)]);\r
+\r
+ float invdet = 1/determinant;\r
+\r
+ inv_transpose_result[M3(0,0)] = (m1[M4(1,1)]*m1[M4(2,2)]-m1[M4(2,1)]*m1[M4(1,2)])*invdet;\r
+ inv_transpose_result[M3(1,0)] = -(m1[M4(0,1)]*m1[M4(2,2)]-m1[M4(0,2)]*m1[M4(2,1)])*invdet;\r
+ inv_transpose_result[M3(2,0)] = (m1[M4(0,1)]*m1[M4(1,2)]-m1[M4(0,2)]*m1[M4(1,1)])*invdet;\r
+ inv_transpose_result[M3(0,1)] = -(m1[M4(1,0)]*m1[M4(2,2)]-m1[M4(1,2)]*m1[M4(2,0)])*invdet;\r
+ inv_transpose_result[M3(1,1)] = (m1[M4(0,0)]*m1[M4(2,2)]-m1[M4(0,2)]*m1[M4(2,0)])*invdet;\r
+ inv_transpose_result[M3(2,1)] = -(m1[M4(0,0)]*m1[M4(1,2)]-m1[M4(1,0)]*m1[M4(0,2)])*invdet;\r
+ inv_transpose_result[M3(0,2)] = (m1[M4(1,0)]*m1[M4(2,1)]-m1[M4(2,0)]*m1[M4(1,1)])*invdet;\r
+ inv_transpose_result[M3(1,2)] = -(m1[M4(0,0)]*m1[M4(2,1)]-m1[M4(2,0)]*m1[M4(0,1)])*invdet;\r
+ inv_transpose_result[M3(2,2)] = (m1[M4(0,0)]*m1[M4(1,1)]-m1[M4(1,0)]*m1[M4(0,1)])*invdet;\r
+\r
+ return inv_transpose_result;\r
+}\r
+\r
+\r
+#if 0\r
+void gl_apply_xform(unsigned int prog)\r
+{\r
+ int loc, mvidx, pidx, tidx, mvtop, ptop, ttop;\r
+\r
+ mvidx = MMODE_IDX(GL_MODELVIEW);\r
+ pidx = MMODE_IDX(GL_PROJECTION);\r
+ tidx = MMODE_IDX(GL_TEXTURE);\r
+\r
+ mvtop = stack_top[mvidx];\r
+ ptop = stack_top[pidx];\r
+ ttop = stack_top[tidx];\r
+\r
+ assert(prog);\r
+\r
+ if((loc = glGetUniformLocation(prog, "matrix_modelview")) != -1) {\r
+ glUniformMatrix4fv(loc, 1, 0, mat_stack[mvidx][mvtop]);\r
+ }\r
+\r
+ if((loc = glGetUniformLocation(prog, "matrix_projection")) != -1) {\r
+ glUniformMatrix4fv(loc, 1, 0, mat_stack[pidx][ptop]);\r
+ }\r
+\r
+ if((loc = glGetUniformLocation(prog, "matrix_texture")) != -1) {\r
+ glUniformMatrix4fv(loc, 1, 0, mat_stack[tidx][ttop]);\r
+ }\r
+\r
+ if((loc = glGetUniformLocation(prog, "matrix_normal")) != -1) {\r
+ float nmat[9];\r
+\r
+ nmat[0] = mat_stack[mvidx][mvtop][0];\r
+ nmat[1] = mat_stack[mvidx][mvtop][1];\r
+ nmat[2] = mat_stack[mvidx][mvtop][2];\r
+ nmat[3] = mat_stack[mvidx][mvtop][4];\r
+ nmat[4] = mat_stack[mvidx][mvtop][5];\r
+ nmat[5] = mat_stack[mvidx][mvtop][6];\r
+ nmat[6] = mat_stack[mvidx][mvtop][8];\r
+ nmat[7] = mat_stack[mvidx][mvtop][9];\r
+ nmat[8] = mat_stack[mvidx][mvtop][10];\r
+ glUniformMatrix3fv(loc, 1, 0, nmat);\r
+ }\r
+}\r
+#endif\r
#include <stdio.h>
#include <stdlib.h>
+#include "glmatrix.h"
+
#ifdef _MSC_VER
/* DUMP MEMORY LEAKS */
#include <crtdbg.h>
#endif
/*
+ * OpenGL 2+ shader mode needs some function and macro definitions,
+ * avoiding a dependency on additional libraries like GLEW or the
+ * GL/glext.h header
+ */
+#ifndef GL_FRAGMENT_SHADER
+#define GL_FRAGMENT_SHADER 0x8B30
+#endif
+
+#ifndef GL_VERTEX_SHADER
+#define GL_VERTEX_SHADER 0x8B31
+#endif
+
+#ifndef GL_COMPILE_STATUS
+#define GL_COMPILE_STATUS 0x8B81
+#endif
+
+#ifndef GL_LINK_STATUS
+#define GL_LINK_STATUS 0x8B82
+#endif
+
+#ifndef GL_INFO_LOG_LENGTH
+#define GL_INFO_LOG_LENGTH 0x8B84
+#endif
+
+typedef ptrdiff_t ourGLsizeiptr;
+typedef char ourGLchar;
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+typedef void (APIENTRY *PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
+typedef void (APIENTRY *PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRY *PFNGLBUFFERDATAPROC) (GLenum target, ourGLsizeiptr size, const GLvoid *data, GLenum usage);
+typedef GLuint (APIENTRY *PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (APIENTRY *PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const ourGLchar **string, const GLint *length);
+typedef void (APIENTRY *PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef GLuint (APIENTRY *PFNGLCREATEPROGRAMPROC) (void);
+typedef void (APIENTRY *PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRY *PFNGLLINKPROGRAMPROC) (GLuint program);
+typedef void (APIENTRY *PFNGLUSEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRY *PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+typedef void (APIENTRY *PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, ourGLchar *infoLog);
+typedef void (APIENTRY *PFNGLGETPROGRAMIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY *PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, ourGLchar *infoLog);
+typedef GLint (APIENTRY *PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const ourGLchar *name);
+typedef GLint (APIENTRY *PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const ourGLchar *name);
+typedef void (APIENTRY *PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRY *PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+
+PFNGLCREATESHADERPROC gl_CreateShader;
+PFNGLSHADERSOURCEPROC gl_ShaderSource;
+PFNGLCOMPILESHADERPROC gl_CompileShader;
+PFNGLCREATEPROGRAMPROC gl_CreateProgram;
+PFNGLATTACHSHADERPROC gl_AttachShader;
+PFNGLLINKPROGRAMPROC gl_LinkProgram;
+PFNGLUSEPROGRAMPROC gl_UseProgram;
+PFNGLGETSHADERIVPROC gl_GetShaderiv;
+PFNGLGETSHADERINFOLOGPROC gl_GetShaderInfoLog;
+PFNGLGETPROGRAMIVPROC gl_GetProgramiv;
+PFNGLGETPROGRAMINFOLOGPROC gl_GetProgramInfoLog;
+PFNGLGETATTRIBLOCATIONPROC gl_GetAttribLocation;
+PFNGLGETUNIFORMLOCATIONPROC gl_GetUniformLocation;
+PFNGLUNIFORMMATRIX4FVPROC gl_UniformMatrix4fv;
+PFNGLUNIFORMMATRIX3FVPROC gl_UniformMatrix3fv;
+
+void initExtensionEntries(void)
+{
+ gl_CreateShader = (PFNGLCREATESHADERPROC) glutGetProcAddress ("glCreateShader");
+ gl_ShaderSource = (PFNGLSHADERSOURCEPROC) glutGetProcAddress ("glShaderSource");
+ gl_CompileShader = (PFNGLCOMPILESHADERPROC) glutGetProcAddress ("glCompileShader");
+ gl_CreateProgram = (PFNGLCREATEPROGRAMPROC) glutGetProcAddress ("glCreateProgram");
+ gl_AttachShader = (PFNGLATTACHSHADERPROC) glutGetProcAddress ("glAttachShader");
+ gl_LinkProgram = (PFNGLLINKPROGRAMPROC) glutGetProcAddress ("glLinkProgram");
+ gl_UseProgram = (PFNGLUSEPROGRAMPROC) glutGetProcAddress ("glUseProgram");
+ gl_GetShaderiv = (PFNGLGETSHADERIVPROC) glutGetProcAddress ("glGetShaderiv");
+ gl_GetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) glutGetProcAddress ("glGetShaderInfoLog");
+ gl_GetProgramiv = (PFNGLGETPROGRAMIVPROC) glutGetProcAddress ("glGetProgramiv");
+ gl_GetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) glutGetProcAddress ("glGetProgramInfoLog");
+ gl_GetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) glutGetProcAddress ("glGetAttribLocation");
+ gl_GetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) glutGetProcAddress ("glGetUniformLocation");
+ gl_UniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) glutGetProcAddress ("glUniformMatrix4fv");
+ gl_UniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) glutGetProcAddress ("glUniformMatrix3fv");
+}
+
+const ourGLchar *vertexShaderSource[] = {
+ "/**",
+ " * From the OpenGL Programming wikibook: http://en.wikibooks.org/wiki/GLSL_Programming/GLUT/Smooth_Specular_Highlights",
+ " * This file is in the public domain.",
+ " * Contributors: Sylvain Beucler",
+ " */",
+ "attribute vec3 fg_coord;",
+ "attribute vec3 fg_normal;",
+ "varying vec4 position; // position of the vertex (and fragment) in world space",
+ "varying vec3 varyingNormalDirection; // surface normal vector in world space",
+ "uniform mat4 m, p; // don't need v, as always identity in our demo",
+ "uniform mat3 m_3x3_inv_transp;",
+ " ",
+ "void main()",
+ "{",
+ " vec4 fg_coord4 = vec4(fg_coord, 1.0);",
+ " position = m * fg_coord4;",
+ " varyingNormalDirection = normalize(m_3x3_inv_transp * fg_normal);",
+ " ",
+ " mat4 mvp = p*m; // normally p*v*m",
+ " gl_Position = mvp * fg_coord4;",
+ "}"
+};
+
+const ourGLchar *fragmentShaderSource[] = {
+ "/**",
+ " * From the OpenGL Programming wikibook: http://en.wikibooks.org/wiki/GLSL_Programming/GLUT/Smooth_Specular_Highlights",
+ " * This file is in the public domain.",
+ " * Contributors: Martin Kraus, Sylvain Beucler",
+ " */",
+ "varying vec4 position; // position of the vertex (and fragment) in world space",
+ "varying vec3 varyingNormalDirection; // surface normal vector in world space",
+ "//uniform mat4 v_inv; // in this demo, the view matrix is always an identity matrix",
+ " ",
+ "struct lightSource",
+ "{",
+ " vec4 position;",
+ " vec4 diffuse;",
+ " vec4 specular;",
+ " float constantAttenuation, linearAttenuation, quadraticAttenuation;",
+ " float spotCutoff, spotExponent;",
+ " vec3 spotDirection;",
+ "};",
+ "lightSource light0 = lightSource(",
+ " vec4(2.0, 5.0, 5.0, 0.0),",
+ " vec4(1.0, 1.0, 1.0, 1.0),",
+ " vec4(1.0, 1.0, 1.0, 1.0),",
+ " 0.0, 1.0, 0.0,",
+ " 180.0, 0.0,",
+ " vec3(0.0, 0.0, 0.0)",
+ ");",
+ "vec4 scene_ambient = vec4(1.0, 0.0, 0.0, 1.0);",
+ " ",
+ "struct material",
+ "{",
+ " vec4 ambient;",
+ " vec4 diffuse;",
+ " vec4 specular;",
+ " float shininess;",
+ "};",
+ "material frontMaterial = material(",
+ " vec4(0.7, 0.7, 0.7, 1.0),",
+ " vec4(0.8, 0.8, 0.8, 1.0),",
+ " vec4(1.0, 1.0, 1.0, 1.0),",
+ " 100.0",
+ ");",
+ " ",
+ "void main()",
+ "{",
+ " vec3 normalDirection = normalize(varyingNormalDirection);",
+ " //vec3 viewDirection = normalize(vec3(v_inv * vec4(0.0, 0.0, 0.0, 1.0) - position));",
+ " vec3 viewDirection = normalize(vec3(vec4(0.0, 0.0, 0.0, 1.0) - position)); // in this demo, the view matrix is always an identity matrix",
+ " vec3 lightDirection;",
+ " float attenuation;",
+ " ",
+ " if (0.0 == light0.position.w) // directional light?",
+ " {",
+ " attenuation = 1.0; // no attenuation",
+ " lightDirection = normalize(vec3(light0.position));",
+ " } ",
+ " else // point light or spotlight (or other kind of light) ",
+ " {",
+ " vec3 positionToLightSource = vec3(light0.position - position);",
+ " float distance = length(positionToLightSource);",
+ " lightDirection = normalize(positionToLightSource);",
+ " attenuation = 1.0 / (light0.constantAttenuation",
+ " + light0.linearAttenuation * distance",
+ " + light0.quadraticAttenuation * distance * distance);",
+ " ",
+ " if (light0.spotCutoff <= 90.0) // spotlight?",
+ " {",
+ " float clampedCosine = max(0.0, dot(-lightDirection, light0.spotDirection));",
+ " if (clampedCosine < cos(radians(light0.spotCutoff))) // outside of spotlight cone?",
+ " {",
+ " attenuation = 0.0;",
+ " }",
+ " else",
+ " {",
+ " attenuation = attenuation * pow(clampedCosine, light0.spotExponent); ",
+ " }",
+ " }",
+ " }",
+ " ",
+ " vec3 ambientLighting = vec3(scene_ambient) * vec3(frontMaterial.ambient);",
+ " ",
+ " vec3 diffuseReflection = attenuation ",
+ " * vec3(light0.diffuse) * vec3(frontMaterial.diffuse)",
+ " * max(0.0, dot(normalDirection, lightDirection));",
+ " ",
+ " vec3 specularReflection;",
+ " if (dot(normalDirection, lightDirection) < 0.0) // light source on the wrong side?",
+ " {",
+ " specularReflection = vec3(0.0, 0.0, 0.0); // no specular reflection",
+ " }",
+ " else // light source on the right side",
+ " {",
+ " specularReflection = attenuation * vec3(light0.specular) * vec3(frontMaterial.specular) ",
+ " * pow(max(0.0, dot(reflect(-lightDirection, normalDirection), viewDirection)), frontMaterial.shininess);",
+ " }",
+ " ",
+ " gl_FragColor = vec4(ambientLighting + diffuseReflection + specularReflection, 1.0);",
+ "}"
+};
+
+GLint getAttribOrUniformLocation(const char* name, GLuint program, GLboolean isAttrib)
+{
+ if (isAttrib)
+ {
+ GLint attrib = gl_GetAttribLocation(program, name);
+ if (attrib == -1)
+ {
+ fprintf(stderr, "Warning: Could not bind attrib %s\n", name);
+ }
+
+ return attrib;
+ }
+ else
+ {
+ GLint uniform = gl_GetUniformLocation(program, name);
+ if (uniform == -1)
+ {
+ fprintf(stderr, "Warning: Could not bind uniform %s\n", name);
+ }
+
+ return uniform;
+ }
+}
+
+GLuint program;
+GLint attribute_fg_coord = -1, attribute_fg_normal = -1;
+GLint uniform_m = -1, uniform_p = -1, uniform_m_3x3_inv_transp = -1;
+GLint shaderReady = 0; // Set to 1 when all initialization went well, to -1 when somehow unusable.
+
+
+
+void compileAndCheck(GLuint shader)
+{
+ GLint status;
+ gl_CompileShader (shader);
+ gl_GetShaderiv (shader, GL_COMPILE_STATUS, &status);
+ if (status == GL_FALSE) {
+ GLint infoLogLength;
+ ourGLchar *infoLog;
+ gl_GetShaderiv (shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+ infoLog = (ourGLchar*) malloc (infoLogLength);
+ gl_GetShaderInfoLog (shader, infoLogLength, NULL, infoLog);
+ fprintf (stderr, "compile log: %s\n", infoLog);
+ free (infoLog);
+ }
+}
+
+GLuint compileShaderSource(GLenum type, GLsizei count, const ourGLchar **string)
+{
+ GLuint shader = gl_CreateShader (type);
+ gl_ShaderSource (shader, count, string, NULL);
+ compileAndCheck (shader);
+ return shader;
+}
+
+void linkAndCheck(GLuint program)
+{
+ GLint status;
+ gl_LinkProgram (program);
+ gl_GetProgramiv (program, GL_LINK_STATUS, &status);
+ if (status == GL_FALSE) {
+ GLint infoLogLength;
+ ourGLchar *infoLog;
+ gl_GetProgramiv (program, GL_INFO_LOG_LENGTH, &infoLogLength);
+ infoLog = (ourGLchar*) malloc (infoLogLength);
+ gl_GetProgramInfoLog (program, infoLogLength, NULL, infoLog);
+ fprintf (stderr, "link log: %s\n", infoLog);
+ free (infoLog);
+ }
+}
+
+void createProgram(GLuint vertexShader, GLuint fragmentShader)
+{
+ program = gl_CreateProgram ();
+ if (vertexShader != 0) {
+ gl_AttachShader (program, vertexShader);
+ }
+ if (fragmentShader != 0) {
+ gl_AttachShader (program, fragmentShader);
+ }
+ linkAndCheck (program);
+}
+
+void initShader(void)
+{
+ const GLsizei vertexShaderLines = sizeof(vertexShaderSource) / sizeof(ourGLchar*);
+ GLuint vertexShader =
+ compileShaderSource (GL_VERTEX_SHADER, vertexShaderLines, vertexShaderSource);
+
+ const GLsizei fragmentShaderLines = sizeof(fragmentShaderSource) / sizeof(ourGLchar*);
+ GLuint fragmentShader =
+ compileShaderSource (GL_FRAGMENT_SHADER, fragmentShaderLines, fragmentShaderSource);
+
+ createProgram (vertexShader, fragmentShader);
+
+ gl_UseProgram (program);
+
+ attribute_fg_coord = getAttribOrUniformLocation("fg_coord" , program, TRUE);
+ attribute_fg_normal = getAttribOrUniformLocation("fg_normal" , program, TRUE);
+ uniform_m = getAttribOrUniformLocation("m" , program, FALSE);
+ uniform_p = getAttribOrUniformLocation("p" , program, FALSE);
+ uniform_m_3x3_inv_transp= getAttribOrUniformLocation("m_3x3_inv_transp" , program, FALSE);
+
+ gl_UseProgram (0);
+
+ if (attribute_fg_coord==-1 || attribute_fg_normal==-1 ||
+ uniform_m==-1 || uniform_p==-1 || uniform_m_3x3_inv_transp==-1)
+ shaderReady = -1;
+ else
+ shaderReady = 1;
+}
+
+/*
* This macro is only intended to be used on arrays, of course.
*/
#define NUMBEROF(x) ((sizeof(x))/(sizeof(x[0])))
static float ar;
static GLboolean persProject = GL_TRUE;
static GLboolean animateXRot = GL_FALSE;
+static GLboolean useShader = GL_FALSE;
/*
* These one-liners draw particular objects, fetching appropriate
const double a = t*90.0;
const double b = (animateXRot?t:1)*60.0;
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- if (persProject)
- glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
- else
- glOrtho(-ar*3, ar*3, -3.0, 3.0, 2.0, 100.0);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- glEnable(GL_LIGHTING);
-
- glColor3d(1,0,0);
-
- glPushMatrix();
- glTranslated(0,1.2,-6);
- glRotated(b,1,0,0);
- glRotated(a,0,0,1);
- table [function_index].solid ();
- glPopMatrix();
-
- glPushMatrix();
- glTranslated(0,-1.2,-6);
- glRotated(b,1,0,0);
- glRotated(a,0,0,1);
- table [function_index].wire ();
- glPopMatrix();
+ if (useShader && !shaderReady)
+ initShader();
- glDisable(GL_LIGHTING);
- glColor3d(0.1,0.1,0.4);
+ if (useShader && shaderReady)
+ {
+ // setup use of shader (and vertex buffer by FreeGLUT)
+ gl_UseProgram (program);
+ glutSetVertexAttribCoord3(attribute_fg_coord);
+ glutSetVertexAttribNormal(attribute_fg_normal);
+
+ gl_matrix_mode(GL_PROJECTION);
+ gl_load_identity();
+ if (persProject)
+ gl_frustum(-ar, ar, -1.f, 1.f, 2.f, 100.f);
+ else
+ gl_ortho(-ar*3, ar*3, -3.f, 3.f, 2.f, 100.f);
+ gl_UniformMatrix4fv (uniform_p, 1, GL_FALSE, get_matrix(GL_PROJECTION));
+
+
+ gl_matrix_mode(GL_MODELVIEW);
+ gl_load_identity();
+
+ gl_push_matrix();
+ /* Not in reverse order like normal OpenGL, matrices are multiplied in in order specified in our util library */
+ gl_rotatef((float)a,0,0,1);
+ gl_rotatef((float)b,1,0,0);
+ gl_translatef(0,1.2f,-6);
+ gl_UniformMatrix4fv (uniform_m , 1, GL_FALSE, get_matrix(GL_MODELVIEW));
+ gl_UniformMatrix3fv (uniform_m_3x3_inv_transp, 1, GL_FALSE, get_inv_transpose_3x3(GL_MODELVIEW));
+ table [function_index].solid ();
+ gl_pop_matrix();
+
+ gl_push_matrix();
+ gl_rotatef((float)a,0,0,1);
+ gl_rotatef((float)b,1,0,0);
+ gl_translatef(0,-1.2f,-6);
+ gl_UniformMatrix4fv (uniform_m , 1, GL_FALSE, get_matrix(GL_MODELVIEW));
+ gl_UniformMatrix3fv (uniform_m_3x3_inv_transp, 1, GL_FALSE, get_inv_transpose_3x3(GL_MODELVIEW));
+ table [function_index].wire ();
+ gl_pop_matrix();
+
+ gl_UseProgram (0);
+ glutSetVertexAttribCoord3(-1);
+ glutSetVertexAttribNormal(-1);
+ }
+ else
+ {
+ /* fixed function pipeline */
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ if (persProject)
+ glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
+ else
+ glOrtho(-ar*3, ar*3, -3.0, 3.0, 2.0, 100.0);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ glEnable(GL_LIGHTING);
+
+ glColor3d(1,0,0);
+
+ glPushMatrix();
+ glTranslated(0,1.2,-6);
+ glRotated(b,1,0,0);
+ glRotated(a,0,0,1);
+ table [function_index].solid ();
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslated(0,-1.2,-6);
+ glRotated(b,1,0,0);
+ glRotated(a,0,0,1);
+ table [function_index].wire ();
+ glPopMatrix();
+
+ glDisable(GL_LIGHTING);
+ glColor3d(0.1,0.1,0.4);
+ }
if( show_info ) {
shapesPrintf (1, 1, "Shape PgUp PgDn: %s", table [function_index].name);
shapesPrintf (4, 1, "Depth (): %d", depth);
shapesPrintf (5, 1, "Outer radius Up Down : %f", orad);
shapesPrintf (6, 1, "Inner radius Left Right: %f", irad);
+ if (persProject)
+ shapesPrintf (7, 1, "Perspective projection");
+ else
+ shapesPrintf (7, 1, "Orthographic projection");
+ if (useShader)
+ shapesPrintf (8, 1, "Using shader");
+ else
+ shapesPrintf (8, 1, "Using fixed function pipeline");
} else {
printf ( "Shape %d slides %d stacks %d\n", function_index, slices, stacks ) ;
}
case 'q': glutLeaveMainLoop () ; break;
case 'I':
- case 'i': show_info = ( show_info == GL_TRUE ) ? GL_FALSE : GL_TRUE; break;
+ case 'i': show_info=!show_info; break;
case '=':
case '+': slices++; break;
case 'R':
case 'r': animateXRot=!animateXRot; break;
+ case 'S':
+ case 's': useShader=!useShader; break;
+
default:
break;
}
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
+ initExtensionEntries();
+
glutMainLoop();
#ifdef _MSC_VER
projects / freeglut / commitdiff