diff options
Diffstat (limited to 'hacks/glx/projectiveplane.c')
| -rw-r--r-- | hacks/glx/projectiveplane.c | 1381 |
1 files changed, 1131 insertions, 250 deletions
diff --git a/hacks/glx/projectiveplane.c b/hacks/glx/projectiveplane.c index 5f42d60..1220772 100644 --- a/hacks/glx/projectiveplane.c +++ b/hacks/glx/projectiveplane.c @@ -2,10 +2,10 @@ that rotates in 4d or on which you can walk */ #if 0 -static const char sccsid[] = "@(#)projectiveplane.c 1.1 03/01/14 xlockmore"; +static const char sccsid[] = "@(#)projectiveplane.c 1.1 14/01/03 xlockmore"; #endif -/* Copyright (c) 2013-2020 Carsten Steger <carsten@mirsanmir.org>. */ +/* Copyright (c) 2013-2021 Carsten Steger <carsten@mirsanmir.org>. */ /* * Permission to use, copy, modify, and distribute this software and its @@ -21,9 +21,12 @@ static const char sccsid[] = "@(#)projectiveplane.c 1.1 03/01/14 xlockmore"; * other special, indirect and consequential damages. * * REVISION HISTORY: - * C. Steger - 03/01/14: Initial version - * C. Steger - 03/10/14: Moved the curlicue texture to curlicue.h - * C. Steger - 06/01/20: Added the changing colors mode. + * C. Steger - 14/01/03: Initial version + * C. Steger - 14/10/03: Moved the curlicue texture to curlicue.h + * C. Steger - 20/01/06: Added the changing colors mode + * C. Steger - 20/12/05: Added per-fragment shading + * C. Steger - 20/12/06: Moved all GLSL support code into glsl-utils.[hc] + * C. Steger - 20/12/30: Make the shader code work under macOS and iOS */ /* @@ -225,9 +228,11 @@ static const char sccsid[] = "@(#)projectiveplane.c 1.1 03/01/14 xlockmore"; #define DEF_WALK_DIRECTION "83.0" #define DEF_WALK_SPEED "20.0" + #ifdef STANDALONE -# define DEFAULTS "*delay: 10000 \n" \ +# define DEFAULTS "*delay: 25000 \n" \ "*showFPS: False \n" \ + "*prefersGLSL: True \n" \ # define release_projectiveplane 0 # include "xlockmore.h" /* from the xscreensaver distribution */ @@ -241,6 +246,7 @@ static const char sccsid[] = "@(#)projectiveplane.c 1.1 03/01/14 xlockmore"; # include <X11/keysym.h> #endif +#include "glsl-utils.h" #include "gltrackball.h" #include <float.h> @@ -355,6 +361,13 @@ ENTRYPOINT ModeSpecOpt projectiveplane_opts = #define NUMB 8 +#if !defined(__GNUC__) && !defined(__extension__) + /* don't warn about "string length is greater than the length ISO C89 + compilers are required to support" in these string constants... */ +# define __extension__ /**/ +#endif + + typedef struct { GLint WindH, WindW; GLXContext *glx_context; @@ -398,11 +411,220 @@ typedef struct { Bool button_pressed; /* A random factor to modify the rotation speeds */ float speed_scale; +#ifdef HAVE_GLSL + GLfloat uv[(NUMU+1)*(NUMV+1)][2]; + GLuint indices[4*(NUMU+1)*(NUMV+1)]; + Bool use_shaders, buffers_initialized; + GLuint shader_program; + GLint vertex_uv_index, vertex_t_index, color_index; + GLint mat_rot_index, mat_p_index, bool_persp_index; + GLint off4d_index, off3d_index; + GLint bool_textures_index, draw_lines_index; + GLint glbl_ambient_index, lt_ambient_index; + GLint lt_diffuse_index, lt_specular_index; + GLint lt_direction_index, lt_halfvect_index; + GLint front_ambient_index, back_ambient_index; + GLint front_diffuse_index, back_diffuse_index; + GLint specular_index, shininess_index; + GLint texture_sampler_index; + GLuint vertex_uv_buffer, vertex_t_buffer; + GLuint color_buffer, indices_buffer; + GLint ni, ne, nt; +#endif /* HAVE_GLSL */ } projectiveplanestruct; static projectiveplanestruct *projectiveplane = (projectiveplanestruct *) NULL; +#ifdef HAVE_GLSL + +/* The GLSL versions that correspond to different versions of OpenGL. */ +static const GLchar *shader_version_2_1 = + "#version 120\n"; +static const GLchar *shader_version_3_0 = + "#version 130\n"; +static const GLchar *shader_version_3_0_es = + "#version 300 es\n" + "precision highp float;\n" + "precision highp int;\n"; + +/* The vertex shader code is composed of code fragments that depend on + the OpenGL version and code fragments that are version-independent. + They are concatenated by glsl_CompileAndLinkShaders in the function + init_glsl(). */ +static const GLchar *vertex_shader_attribs_2_1 = + "attribute vec2 VertexUV;\n" + "attribute vec4 VertexT;\n" + "attribute vec4 VertexColor;\n" + "\n" + "varying vec3 Normal;\n" + "varying vec4 Color;\n" + "varying vec4 TexCoord;\n" + "\n"; +static const GLchar *vertex_shader_attribs_3_0 = + "in vec2 VertexUV;\n" + "in vec4 VertexT;\n" + "in vec4 VertexColor;\n" + "\n" + "out vec3 Normal;\n" + "out vec4 Color;\n" + "out vec4 TexCoord;\n" + "\n"; +static const GLchar *vertex_shader_main = + __extension__ + "uniform mat4 MatRot4D;\n" + "uniform mat4 MatProj;\n" + "uniform bool BoolPersp;\n" + "uniform vec4 Offset4D;\n" + "uniform vec4 Offset3D;\n" + "uniform bool BoolTextures;\n" + "\n" + "void main (void)\n" + "{\n" + " const float EPSILON = 1.0e-7f;\n" + " float u, v, su, cu, s2u, c2u, sv2, cv2, sv4, cv4;\n" + " vec3 p, pu, pv;\n" + " u = VertexUV.x;\n" + " v = VertexUV.y;\n" + " su = sin(u)\n;" + " cu = cos(u)\n;" + " s2u = sin(2.0f*u)\n;" + " c2u = cos(2.0f*u)\n;" + " sv2 = sin(0.5f*v)\n;" + " cv2 = cos(0.5f*v)\n;" + " sv4 = sin(0.25f*v)\n;" + " cv4 = cos(0.25f*v)\n;" + " vec4 xx = vec4(0.5f*s2u*sv4*sv4,\n" + " 0.5f*su*sv2,\n" + " 0.5f*cu*sv2,\n" + " 0.5f*(su*su*sv4*sv4-cv4*cv4));\n" + " if (v < EPSILON)\n" + " {\n" + " v = EPSILON;\n" + " sv2 = sin(0.5f*v)\n;" + " cv2 = cos(0.5f*v)\n;" + " sv4 = sin(0.25f*v)\n;" + " }\n" + " vec4 xxu = vec4(c2u*sv4*sv4,\n" + " 0.5f*cu*sv2,\n" + " -0.5f*su*sv2,\n" + " 0.5f*s2u*sv4*sv4);\n" + " vec4 xxv = vec4(0.125f*s2u*sv2,\n" + " 0.25f*su*cv2,\n" + " 0.25f*cu*cv2,\n" + " 0.125f*(su*su+1.0f)*sv2);\n" + " vec4 x = MatRot4D*xx+Offset4D;\n" + " vec4 xu = MatRot4D*xxu;\n" + " vec4 xv = MatRot4D*xxv;\n" + " if (BoolPersp)\n" + " {\n" + " vec3 r = x.xyz;\n" + " float s = x.w;\n" + " float t = s*s;\n" + " p = r/s+Offset3D.xyz;\n" + " pu = (s*xu.xyz-r*xu.w)/t;\n" + " pv = (s*xv.xyz-r*xv.w)/t;\n" + " }\n" + " else\n" + " {\n" + " p = x.xyz+Offset3D.xyz;\n" + " pu = xu.xyz;\n" + " pv = xv.xyz;\n" + " }\n" + " vec4 Position = vec4(p,1.0);\n" + " Normal = normalize(cross(pu,pv));\n" + " gl_Position = MatProj*Position;\n" + " Color = VertexColor;\n" + " if (BoolTextures)\n" + " TexCoord = VertexT;\n" + "}\n"; + +/* The fragment shader code is composed of code fragments that depend on + the OpenGL version and code fragments that are version-independent. + They are concatenated by glsl_CompileAndLinkShaders in the function + init_glsl(). */ +static const GLchar *fragment_shader_attribs_2_1 = + "varying vec3 Normal;\n" + "varying vec4 Color;\n" + "varying vec4 TexCoord;\n" + "\n"; +static const GLchar *fragment_shader_attribs_3_0 = + "in vec3 Normal;\n" + "in vec4 Color;\n" + "in vec4 TexCoord;\n" + "\n" + "out vec4 FragColor;\n" + "\n"; +static const GLchar *fragment_shader_main = + __extension__ + "uniform bool DrawLines;\n" + "uniform vec4 LtGlblAmbient;\n" + "uniform vec4 LtAmbient, LtDiffuse, LtSpecular;\n" + "uniform vec3 LtDirection, LtHalfVector;\n" + "uniform vec4 MatFrontAmbient, MatBackAmbient;\n" + "uniform vec4 MatFrontDiffuse, MatBackDiffuse;\n" + "uniform vec4 MatSpecular;\n" + "uniform float MatShininess;\n" + "uniform bool BoolTextures;\n" + "uniform sampler2D TextureSampler;" + "\n" + "void main (void)\n" + "{\n" + " vec4 color;\n" + " if (DrawLines)\n" + " {\n" + " color = Color;\n" + " }\n" + " else\n" + " {\n" + " vec3 normalDirection;\n" + " vec4 ambientColor, diffuseColor, sceneColor;\n" + " vec4 ambientLighting, diffuseReflection, specularReflection;\n" + " float ndotl, ndoth, pf;\n" + " \n" + " if (gl_FrontFacing)\n" + " {\n" + " normalDirection = normalize(Normal);\n" + " sceneColor = Color*MatFrontAmbient*LtGlblAmbient;\n" + " ambientColor = Color*MatFrontAmbient;\n" + " diffuseColor = Color*MatFrontDiffuse;\n" + " }\n" + " else\n" + " {\n" + " normalDirection = -normalize(Normal);\n" + " sceneColor = Color*MatBackAmbient*LtGlblAmbient;\n" + " ambientColor = Color*MatBackAmbient;\n" + " diffuseColor = Color*MatBackDiffuse;\n" + " }\n" + " \n" + " ndotl = max(0.0,dot(normalDirection,LtDirection));\n" + " ndoth = max(0.0,dot(normalDirection,LtHalfVector));\n" + " if (ndotl == 0.0)\n" + " pf = 0.0;\n" + " else\n" + " pf = pow(ndoth,MatShininess);\n" + " ambientLighting = ambientColor*LtAmbient;\n" + " diffuseReflection = LtDiffuse*diffuseColor*ndotl;\n" + " specularReflection = LtSpecular*MatSpecular*pf;\n" + " color = sceneColor+ambientLighting+diffuseReflection;\n"; +static const GLchar *fragment_shader_out_2_1 = + " if (BoolTextures)\n" + " color *= texture2D(TextureSampler,TexCoord.st);" + " color += specularReflection;\n" + " }\n" + " gl_FragColor = clamp(color,0.0,1.0);\n" + "}\n"; +static const GLchar *fragment_shader_out_3_0 = + " if (BoolTextures)\n" + " color *= texture(TextureSampler,TexCoord.st);" + " color += specularReflection;\n" + " }\n" + " FragColor = clamp(color,0.0,1.0);\n" + "}\n"; + +#endif /* HAVE_GLSL */ + + /* Add a rotation around the wx-plane to the matrix m. */ static void rotatewx(float m[4][4], float phi) { @@ -771,13 +993,13 @@ static void setup_projective_plane(ModeInfo *mi, double umin, double umax, else u = ur*j/NUMU+umin; v = vr*i/NUMV+vmin; - cu = cos(u); su = sin(u); - c2u = cos(2.0*u); + cu = cos(u); s2u = sin(2.0*u); + c2u = cos(2.0*u); sv2 = sin(0.5*v); - cv4 = cos(0.25*v); sv4 = sin(0.25*v); + cv4 = cos(0.25*v); w = 0.5*(su*su*sv4*sv4-cv4*cv4); if (!pp->change_colors) { @@ -800,8 +1022,8 @@ static void setup_projective_plane(ModeInfo *mi, double umin, double umax, /* Avoid degenerate tangential plane basis vectors. */ if (v < FLT_EPSILON) v = FLT_EPSILON; - cv2 = cos(0.5*v); sv2 = sin(0.5*v); + cv2 = cos(0.5*v); sv4 = sin(0.25*v); pp->xu[k][0] = c2u*sv4*sv4; pp->xu[k][1] = 0.5*cu*sv2; @@ -816,11 +1038,161 @@ static void setup_projective_plane(ModeInfo *mi, double umin, double umax, } -/* Draw a 4d embedding of the projective plane projected into 3D. */ -static int projective_plane(ModeInfo *mi, double umin, double umax, - double vmin, double vmax) +/* Compute the current walk frame, i.e., the coordinate system of the + point and direction at which the viewer is currently walking on the + projective plane. */ +static void compute_walk_frame(projectiveplanestruct *pp, float mat[4][4]) +{ + int l, m; + double u, v; + double q, r, s, t; + double cu, su, cv2, sv2, cv4, sv4, c2u, s2u; + float p[3], pu[3], pv[3], pm[3], n[3], b[3]; + double xx[4], xxu[4], xxv[4], y[4], yu[4], yv[4]; + + /* Compute the rotation that rotates the projective plane in 4D without + the trackball rotations. */ + rotateall4d(pp->zeta,pp->eta,pp->theta,mat); + + u = pp->umove; + v = pp->vmove; + su = sin(u); + cu = cos(u); + s2u = sin(2.0*u); + c2u = cos(2.0*u); + sv2 = sin(0.5*v); + sv4 = sin(0.25*v); + cv4 = cos(0.25*v); + xx[0] = 0.5*s2u*sv4*sv4; + xx[1] = 0.5*su*sv2; + xx[2] = 0.5*cu*sv2; + xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4); + /* Avoid degenerate tangential plane basis vectors. */ + if (v < FLT_EPSILON) + v = FLT_EPSILON; + sv2 = sin(0.5*v); + cv2 = cos(0.5*v); + sv4 = sin(0.25*v); + xxu[0] = c2u*sv4*sv4; + xxu[1] = 0.5*cu*sv2; + xxu[2] = -0.5*su*sv2; + xxu[3] = 0.5*s2u*sv4*sv4; + xxv[0] = 0.125*s2u*sv2; + xxv[1] = 0.25*su*cv2; + xxv[2] = 0.25*cu*cv2; + xxv[3] = 0.125*(su*su+1.0)*sv2; + for (l=0; l<4; l++) + { + y[l] = (mat[l][0]*xx[0]+mat[l][1]*xx[1]+ + mat[l][2]*xx[2]+mat[l][3]*xx[3]); + yu[l] = (mat[l][0]*xxu[0]+mat[l][1]*xxu[1]+ + mat[l][2]*xxu[2]+mat[l][3]*xxu[3]); + yv[l] = (mat[l][0]*xxv[0]+mat[l][1]*xxv[1]+ + mat[l][2]*xxv[2]+mat[l][3]*xxv[3]); + } + if (pp->projection_4d == DISP_4D_ORTHOGRAPHIC) + { + for (l=0; l<3; l++) + { + p[l] = y[l]+pp->offset4d[l]; + pu[l] = yu[l]; + pv[l] = yv[l]; + } + } + else + { + s = y[3]+pp->offset4d[3]; + q = 1.0/s; + t = q*q; + for (l=0; l<3; l++) + { + r = y[l]+pp->offset4d[l]; + p[l] = r*q; + pu[l] = (yu[l]*s-r*yu[3])*t; + pv[l] = (yv[l]*s-r*yv[3])*t; + } + } + n[0] = pu[1]*pv[2]-pu[2]*pv[1]; + n[1] = pu[2]*pv[0]-pu[0]*pv[2]; + n[2] = pu[0]*pv[1]-pu[1]*pv[0]; + t = 1.0/(pp->side*4.0*sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2])); + n[0] *= t; + n[1] *= t; + n[2] *= t; + pm[0] = pu[0]*pp->dumove+pv[0]*pp->dvmove; + pm[1] = pu[1]*pp->dumove+pv[1]*pp->dvmove; + pm[2] = pu[2]*pp->dumove+pv[2]*pp->dvmove; + t = 1.0/(4.0*sqrt(pm[0]*pm[0]+pm[1]*pm[1]+pm[2]*pm[2])); + pm[0] *= t; + pm[1] *= t; + pm[2] *= t; + b[0] = n[1]*pm[2]-n[2]*pm[1]; + b[1] = n[2]*pm[0]-n[0]*pm[2]; + b[2] = n[0]*pm[1]-n[1]*pm[0]; + t = 1.0/(4.0*sqrt(b[0]*b[0]+b[1]*b[1]+b[2]*b[2])); + b[0] *= t; + b[1] *= t; + b[2] *= t; + + /* Compute alpha, beta, delta from the three basis vectors. + | -b[0] -b[1] -b[2] | + m = | n[0] n[1] n[2] | + | -pm[0] -pm[1] -pm[2] | + */ + pp->alpha = atan2(-n[2],-pm[2])*180/M_PI; + pp->beta = atan2(-b[2],sqrt(b[0]*b[0]+b[1]*b[1]))*180/M_PI; + pp->delta = atan2(b[1],-b[0])*180/M_PI; + + /* Compute the rotation that rotates the projective plane in 4D. */ + rotateall(pp->alpha,pp->beta,pp->delta,pp->zeta,pp->eta,pp->theta,mat); + + u = pp->umove; + v = pp->vmove; + su = sin(u); + cu = cos(u); + s2u = sin(2.0*u); + sv2 = sin(0.5*v); + sv4 = sin(0.25*v); + cv4 = cos(0.25*v); + xx[0] = 0.5*s2u*sv4*sv4; + xx[1] = 0.5*su*sv2; + xx[2] = 0.5*cu*sv2; + xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4); + for (l=0; l<4; l++) + { + r = 0.0; + for (m=0; m<4; m++) + r += mat[l][m]*xx[m]; + y[l] = r; + } + if (pp->projection_4d == DISP_4D_ORTHOGRAPHIC) + { + for (l=0; l<3; l++) + p[l] = y[l]+pp->offset4d[l]; + } + else + { + s = y[3]+pp->offset4d[3]; + for (l=0; l<3; l++) + p[l] = (y[l]+pp->offset4d[l])/s; + } + + pp->offset3d[0] = -p[0]; + pp->offset3d[1] = -p[1]-DELTAY; + pp->offset3d[2] = -p[2]; +} + + +/* Draw a 4d embedding of the projective plane projected into 3D using + OpenGL's fixed functionality. */ +static int projective_plane_ff(ModeInfo *mi, double umin, double umax, + double vmin, double vmax) { - int polys = 0; + static const GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 }; + static const GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; + static const GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; + static const GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; + static const GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; static const GLfloat mat_diff_red[] = { 1.0, 0.0, 0.0, 1.0 }; static const GLfloat mat_diff_green[] = { 0.0, 1.0, 0.0, 1.0 }; static const GLfloat mat_diff_oneside[] = { 0.9, 0.4, 0.3, 1.0 }; @@ -828,150 +1200,105 @@ static int projective_plane(ModeInfo *mi, double umin, double umax, static const GLfloat mat_diff_trans_green[] = { 0.0, 1.0, 0.0, 0.7 }; static const GLfloat mat_diff_trans_oneside[] = { 0.9, 0.4, 0.3, 0.7 }; float mat_diff_dyn[4], mat_diff_dyn_compl[4]; - float p[3], pu[3], pv[3], pm[3], n[3], b[3], mat[4][4], matc[3][3]; + float pu[3], pv[3], mat[4][4], matc[3][3]; int i, j, k, l, m, o; double u, v, ur, vr; - double xx[4], xxu[4], xxv[4], y[4], yu[4], yv[4]; + double y[4], yu[4], yv[4]; double q, r, s, t; - double cu, su, cv2, sv2, cv4, sv4, c2u, s2u; float q1[4], q2[4], r1[4][4], r2[4][4]; projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; + int polys; + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + if (pp->projection_3d == DISP_3D_PERSPECTIVE || + pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) + { + if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) + gluPerspective(60.0,pp->aspect,0.01,10.0); + else + gluPerspective(60.0,pp->aspect,0.1,10.0); + } + else + { + if (pp->aspect >= 1.0) + glOrtho(-0.6*pp->aspect,0.6*pp->aspect,-0.6,0.6,0.1,10.0); + else + glOrtho(-0.6,0.6,-0.6/pp->aspect,0.6/pp->aspect,0.1,10.0); + } + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + if (pp->display_mode == DISP_SURFACE) + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glDepthMask(GL_TRUE); + glShadeModel(GL_SMOOTH); + glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient); + glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse); + glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular); + glLightfv(GL_LIGHT0,GL_POSITION,light_position); + glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular); + glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0); + glDisable(GL_BLEND); + } + else if (pp->display_mode == DISP_TRANSPARENT) + { + glDisable(GL_DEPTH_TEST); + glDepthMask(GL_FALSE); + glShadeModel(GL_SMOOTH); + glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); + glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient); + glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse); + glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular); + glLightfv(GL_LIGHT0,GL_POSITION,light_position); + glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular); + glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA,GL_ONE); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glDepthMask(GL_TRUE); + glShadeModel(GL_FLAT); + glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); + glDisable(GL_LIGHTING); + glDisable(GL_LIGHT0); + glDisable(GL_BLEND); + } + + if (pp->marks) + { + glEnable(GL_TEXTURE_2D); +#ifndef HAVE_JWZGLES + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR); +#endif + } + else + { + glDisable(GL_TEXTURE_2D); +#ifndef HAVE_JWZGLES + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR); +#endif + } if (pp->change_colors) rotateall3d(pp->rho,pp->sigma,pp->tau,matc); if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) { - /* Compute the rotation that rotates the projective plane in 4D without - the trackball rotations. */ - rotateall4d(pp->zeta,pp->eta,pp->theta,mat); - - u = pp->umove; - v = pp->vmove; - cu = cos(u); - su = sin(u); - c2u = cos(2.0*u); - s2u = sin(2.0*u); - sv2 = sin(0.5*v); - cv4 = cos(0.25*v); - sv4 = sin(0.25*v); - xx[0] = 0.5*s2u*sv4*sv4; - xx[1] = 0.5*su*sv2; - xx[2] = 0.5*cu*sv2; - xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4); - /* Avoid degenerate tangential plane basis vectors. */ - if (v < FLT_EPSILON) - v = FLT_EPSILON; - cv2 = cos(0.5*v); - sv2 = sin(0.5*v); - sv4 = sin(0.25*v); - xxu[0] = c2u*sv4*sv4; - xxu[1] = 0.5*cu*sv2; - xxu[2] = -0.5*su*sv2; - xxu[3] = 0.5*s2u*sv4*sv4; - xxv[0] = 0.125*s2u*sv2; - xxv[1] = 0.25*su*cv2; - xxv[2] = 0.25*cu*cv2; - xxv[3] = 0.125*(su*su+1.0)*sv2; - for (l=0; l<4; l++) - { - y[l] = (mat[l][0]*xx[0]+mat[l][1]*xx[1]+ - mat[l][2]*xx[2]+mat[l][3]*xx[3]); - yu[l] = (mat[l][0]*xxu[0]+mat[l][1]*xxu[1]+ - mat[l][2]*xxu[2]+mat[l][3]*xxu[3]); - yv[l] = (mat[l][0]*xxv[0]+mat[l][1]*xxv[1]+ - mat[l][2]*xxv[2]+mat[l][3]*xxv[3]); - } - if (pp->projection_4d == DISP_4D_ORTHOGRAPHIC) - { - for (l=0; l<3; l++) - { - p[l] = y[l]+pp->offset4d[l]; - pu[l] = yu[l]; - pv[l] = yv[l]; - } - } - else - { - s = y[3]+pp->offset4d[3]; - q = 1.0/s; - t = q*q; - for (l=0; l<3; l++) - { - r = y[l]+pp->offset4d[l]; - p[l] = r*q; - pu[l] = (yu[l]*s-r*yu[3])*t; - pv[l] = (yv[l]*s-r*yv[3])*t; - } - } - n[0] = pu[1]*pv[2]-pu[2]*pv[1]; - n[1] = pu[2]*pv[0]-pu[0]*pv[2]; - n[2] = pu[0]*pv[1]-pu[1]*pv[0]; - t = 1.0/(pp->side*4.0*sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2])); - n[0] *= t; - n[1] *= t; - n[2] *= t; - pm[0] = pu[0]*pp->dumove+pv[0]*pp->dvmove; - pm[1] = pu[1]*pp->dumove+pv[1]*pp->dvmove; - pm[2] = pu[2]*pp->dumove+pv[2]*pp->dvmove; - t = 1.0/(4.0*sqrt(pm[0]*pm[0]+pm[1]*pm[1]+pm[2]*pm[2])); - pm[0] *= t; - pm[1] *= t; - pm[2] *= t; - b[0] = n[1]*pm[2]-n[2]*pm[1]; - b[1] = n[2]*pm[0]-n[0]*pm[2]; - b[2] = n[0]*pm[1]-n[1]*pm[0]; - t = 1.0/(4.0*sqrt(b[0]*b[0]+b[1]*b[1]+b[2]*b[2])); - b[0] *= t; - b[1] *= t; - b[2] *= t; - - /* Compute alpha, beta, delta from the three basis vectors. - | -b[0] -b[1] -b[2] | - m = | n[0] n[1] n[2] | - | -pm[0] -pm[1] -pm[2] | - */ - pp->alpha = atan2(-n[2],-pm[2])*180/M_PI; - pp->beta = atan2(-b[2],sqrt(b[0]*b[0]+b[1]*b[1]))*180/M_PI; - pp->delta = atan2(b[1],-b[0])*180/M_PI; - - /* Compute the rotation that rotates the projective plane in 4D. */ - rotateall(pp->alpha,pp->beta,pp->delta,pp->zeta,pp->eta,pp->theta,mat); - - u = pp->umove; - v = pp->vmove; - cu = cos(u); - su = sin(u); - s2u = sin(2.0*u); - sv2 = sin(0.5*v); - cv4 = cos(0.25*v); - sv4 = sin(0.25*v); - xx[0] = 0.5*s2u*sv4*sv4; - xx[1] = 0.5*su*sv2; - xx[2] = 0.5*cu*sv2; - xx[3] = 0.5*(su*su*sv4*sv4-cv4*cv4); - for (l=0; l<4; l++) - { - r = 0.0; - for (m=0; m<4; m++) - r += mat[l][m]*xx[m]; - y[l] = r; - } - if (pp->projection_4d == DISP_4D_ORTHOGRAPHIC) - { - for (l=0; l<3; l++) - p[l] = y[l]+pp->offset4d[l]; - } - else - { - s = y[3]+pp->offset4d[3]; - for (l=0; l<3; l++) - p[l] = (y[l]+pp->offset4d[l])/s; - } - - pp->offset3d[0] = -p[0]; - pp->offset3d[1] = -p[1]-DELTAY; - pp->offset3d[2] = -p[2]; + /* Compute the walk frame. */ + compute_walk_frame(pp,mat); } else { @@ -1103,7 +1430,7 @@ static int projective_plane(ModeInfo *mi, double umin, double umax, { for (k=0; k<=1; k++) { - l = (i+k); + l = i+k; m = j; o = l*(NUMU+1)+m; glNormal3fv(pp->pn[o]); @@ -1131,7 +1458,6 @@ static int projective_plane(ModeInfo *mi, double umin, double umax, glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,pp->col[o]); } glVertex3fv(pp->pp[o]); - polys++; } } glEnd(); @@ -1152,7 +1478,7 @@ static int projective_plane(ModeInfo *mi, double umin, double umax, for (k=0; k<=1; k++) { l = i; - m = (j+k); + m = j+k; o = l*(NUMU+1)+m; glNormal3fv(pp->pn[o]); glTexCoord2fv(pp->tex[o]); @@ -1179,26 +1505,505 @@ static int projective_plane(ModeInfo *mi, double umin, double umax, glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,pp->col[o]); } glVertex3fv(pp->pp[o]); - polys++; } } glEnd(); } } - polys /= 2; + polys = 2*NUMU*NUMV; + if (pp->appearance != APPEARANCE_SOLID) + polys /= 2; + return polys; +} + + +#ifdef HAVE_GLSL + +/* Draw a 4d embedding of the projective plane projected into 3D using + OpenGL's programmable functionality. */ +static int projective_plane_pf(ModeInfo *mi, double umin, double umax, + double vmin, double vmax) +{ + static const GLfloat light_model_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; + static const GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 }; + static const GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; + static const GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; + static const GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; + static const GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; + static const GLfloat mat_diff_red[] = { 1.0, 0.0, 0.0, 1.0 }; + static const GLfloat mat_diff_green[] = { 0.0, 1.0, 0.0, 1.0 }; + static const GLfloat mat_diff_oneside[] = { 0.9, 0.4, 0.3, 1.0 }; + static const GLfloat mat_diff_trans_red[] = { 1.0, 0.0, 0.0, 0.7 }; + static const GLfloat mat_diff_trans_green[] = { 0.0, 1.0, 0.0, 0.7 }; + static const GLfloat mat_diff_trans_oneside[] = { 0.9, 0.4, 0.3, 0.7 }; + static const GLfloat mat_diff_white[] = { 1.0, 1.0, 1.0, 1.0 }; + GLfloat light_direction[3], half_vector[3], len; + GLfloat p_mat[16]; + float mat_diff_dyn[4], mat_diff_dyn_compl[4]; + float mat[4][4], matc[3][3]; + int i, j, k, l, m, o; + double u, v, ur, vr; + float q1[4], q2[4], r1[4][4], r2[4][4]; + GLsizeiptr index_offset; + projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; + int polys; + + if (!pp->use_shaders) + return 0; + + if (!pp->buffers_initialized) + { + /* The u and v values need to be computed once (or each time the value + of appearance changes, once we support that). */ + ur = umax-umin; + vr = vmax-vmin; + for (i=0; i<=NUMV; i++) + { + for (j=0; j<=NUMU; j++) + { + o = i*(NUMU+1)+j; + if (pp->appearance != APPEARANCE_DIRECTION_BANDS) + u = -ur*j/NUMU+umin; + else + u = ur*j/NUMU+umin; + v = vr*i/NUMV+vmin; + pp->uv[o][0] = u; + pp->uv[o][1] = v; + } + } + glBindBuffer(GL_ARRAY_BUFFER,pp->vertex_uv_buffer); + glBufferData(GL_ARRAY_BUFFER,2*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + pp->uv,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + + glBindBuffer(GL_ARRAY_BUFFER,pp->vertex_t_buffer); + glBufferData(GL_ARRAY_BUFFER,2*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + pp->tex,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + + if (!pp->change_colors && + pp->colors != COLORS_ONESIDED && pp->colors != COLORS_TWOSIDED) + { + glBindBuffer(GL_ARRAY_BUFFER,pp->color_buffer); + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + pp->col,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + } + + /* The indices only need to be computed once (or each time the value of + appearance changes, once we support that). */ + pp->ni = 0; + pp->ne = 0; + pp->nt = 0; + if (pp->display_mode != DISP_WIREFRAME) + { + if (pp->appearance != APPEARANCE_DIRECTION_BANDS) + { + for (i=0; i<NUMV; i++) + { + if (pp->appearance == APPEARANCE_DISTANCE_BANDS && + ((i & (NUMB-1)) >= NUMB/4) && ((i & (NUMB-1)) < 3*NUMB/4)) + continue; + for (j=0; j<=NUMU; j++) + { + for (k=0; k<=1; k++) + { + l = i+k; + m = j; + o = l*(NUMU+1)+m; + pp->indices[pp->ni++] = o; + } + } + pp->ne++; + } + pp->nt = 2*(NUMU+1); + } + else /* pp->appearance == APPEARANCE_DIRECTION_BANDS */ + { + for (j=0; j<NUMU; j++) + { + if ((j & (NUMB-1)) >= NUMB/2) + continue; + for (i=0; i<=NUMV; i++) + { + for (k=0; k<=1; k++) + { + l = i; + m = j+k; + o = l*(NUMU+1)+m; + pp->indices[pp->ni++] = o; + } + } + pp->ne++; + } + pp->nt = 2*(NUMV+1); + } + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + if (pp->appearance != APPEARANCE_DIRECTION_BANDS) + { + for (i=0; i<=NUMV; i++) + { + if (pp->appearance == APPEARANCE_DISTANCE_BANDS && + ((i & (NUMB-1)) > NUMB/4) && ((i & (NUMB-1)) < 3*NUMB/4)) + continue; + if (pp->appearance == APPEARANCE_DISTANCE_BANDS && + ((i & (NUMB-1)) == NUMB/4)) + { + for (j=0; j<NUMU; j++) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = i*(NUMU+1)+j+1; + } + continue; + } + for (j=0; j<NUMU; j++) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = i*(NUMU+1)+j+1; + if (i < NUMV) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = (i+1)*(NUMU+1)+j; + } + } + } + } + else /* pp->appearance == APPEARANCE_DIRECTION_BANDS */ + { + for (j=0; j<NUMU; j++) + { + if ((j & (NUMB-1)) > NUMB/2) + continue; + if ((j & (NUMB-1)) == NUMB/2) + { + for (i=0; i<NUMV; i++) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = (i+1)*(NUMU+1)+j; + } + continue; + } + for (i=0; i<=NUMV; i++) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = i*(NUMU+1)+j+1; + if (i < NUMV) + { + pp->indices[pp->ni++] = i*(NUMU+1)+j; + pp->indices[pp->ni++] = (i+1)*(NUMU+1)+j; + } + } + } + } + pp->ne = 1; + } + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,pp->indices_buffer); + glBufferData(GL_ELEMENT_ARRAY_BUFFER,pp->ni*sizeof(GLuint), + pp->indices,GL_STATIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + + pp->buffers_initialized = True; + } + + if (pp->change_colors) + rotateall3d(pp->rho,pp->sigma,pp->tau,matc); + + if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) + { + /* Compute the walk frame. */ + compute_walk_frame(pp,mat); + } + else + { + /* Compute the rotation that rotates the projective plane in 4D, + including the trackball rotations. */ + rotateall(pp->alpha,pp->beta,pp->delta,pp->zeta,pp->eta,pp->theta,r1); + + gltrackball_get_quaternion(pp->trackballs[0],q1); + gltrackball_get_quaternion(pp->trackballs[1],q2); + quats_to_rotmat(q1,q2,r2); + + mult_rotmat(r2,r1,mat); + } + + if (pp->change_colors && + (pp->colors == COLORS_DEPTH || pp->colors == COLORS_DIRECTION || + pp->colors == COLORS_DISTANCE)) + { + ur = umax-umin; + vr = vmax-vmin; + for (i=0; i<=NUMV; i++) + { + for (j=0; j<=NUMU; j++) + { + o = i*(NUMU+1)+j; + if (pp->colors == COLORS_DEPTH) + { + color(pp,(2.0*pp->x[o][3]+1.0)*M_PI*2.0/3.0,matc,pp->col[o]); + } + else if (pp->colors == COLORS_DIRECTION) + { + u = -ur*j/NUMU+umin; + color(pp,2.0*M_PI+fmod(2.0*u,2.0*M_PI),matc,pp->col[o]); + } + else if (pp->colors == COLORS_DISTANCE) + { + v = vr*i/NUMV+vmin; + color(pp,v*(5.0/6.0),matc,pp->col[o]); + } + } + } + } + + glUseProgram(pp->shader_program); + + glsl_Identity(p_mat); + if (pp->projection_3d == DISP_3D_PERSPECTIVE || + pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) + { + if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) + glsl_Perspective(p_mat,60.0f,pp->aspect,0.01f,10.0f); + else + glsl_Perspective(p_mat,60.0f,pp->aspect,0.1f,10.0f); + } + else + { + if (pp->aspect >= 1.0) + glsl_Orthographic(p_mat,-0.6f*pp->aspect,0.6f*pp->aspect,-0.6f,0.6f, + 0.1f,10.0f); + else + glsl_Orthographic(p_mat,-0.6f,0.6f,-0.6f/pp->aspect,0.6f/pp->aspect, + 0.1f,10.0f); + } + glUniformMatrix4fv(pp->mat_rot_index,1,GL_TRUE,(GLfloat *)mat); + glUniformMatrix4fv(pp->mat_p_index,1,GL_FALSE,p_mat); + glUniform1i(pp->bool_persp_index,pp->projection_4d == DISP_4D_PERSPECTIVE); + glUniform4fv(pp->off4d_index,1,pp->offset4d); + glUniform4fv(pp->off3d_index,1,pp->offset3d); + + len = sqrtf(light_position[0]*light_position[0]+ + light_position[1]*light_position[1]+ + light_position[2]*light_position[2]); + light_direction[0] = light_position[0]/len; + light_direction[1] = light_position[1]/len; + light_direction[2] = light_position[2]/len; + half_vector[0] = light_direction[0]; + half_vector[1] = light_direction[1]; + half_vector[2] = light_direction[2]+1.0f; + len = sqrtf(half_vector[0]*half_vector[0]+ + half_vector[1]*half_vector[1]+ + half_vector[2]*half_vector[2]); + half_vector[0] /= len; + half_vector[1] /= len; + half_vector[2] /= len; + + if (pp->display_mode == DISP_SURFACE) + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glDepthMask(GL_TRUE); + glDisable(GL_BLEND); + glUniform4fv(pp->glbl_ambient_index,1,light_model_ambient); + glUniform4fv(pp->lt_ambient_index,1,light_ambient); + glUniform4fv(pp->lt_diffuse_index,1,light_diffuse); + glUniform4fv(pp->lt_specular_index,1,light_specular); + glUniform3fv(pp->lt_direction_index,1,light_direction); + glUniform3fv(pp->lt_halfvect_index,1,half_vector); + glUniform4fv(pp->specular_index,1,mat_specular); + glUniform1f(pp->shininess_index,50.0f); + glUniform1i(pp->draw_lines_index,GL_FALSE); + } + else if (pp->display_mode == DISP_TRANSPARENT) + { + glDisable(GL_DEPTH_TEST); + glDepthMask(GL_FALSE); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA,GL_ONE); + glUniform4fv(pp->glbl_ambient_index,1,light_model_ambient); + glUniform4fv(pp->lt_ambient_index,1,light_ambient); + glUniform4fv(pp->lt_diffuse_index,1,light_diffuse); + glUniform4fv(pp->lt_specular_index,1,light_specular); + glUniform3fv(pp->lt_direction_index,1,light_direction); + glUniform3fv(pp->lt_halfvect_index,1,half_vector); + glUniform4fv(pp->specular_index,1,mat_specular); + glUniform1f(pp->shininess_index,50.0f); + glUniform1i(pp->draw_lines_index,GL_FALSE); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glDepthMask(GL_TRUE); + glDisable(GL_BLEND); + glUniform1i(pp->draw_lines_index,GL_TRUE); + } + + if (pp->marks) + glEnable(GL_TEXTURE_2D); + else + glDisable(GL_TEXTURE_2D); + + glUniform4fv(pp->front_ambient_index,1,mat_diff_white); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_white); + glUniform4fv(pp->back_ambient_index,1,mat_diff_white); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_white); + glVertexAttrib4f(pp->color_index,1.0f,1.0f,1.0f,1.0f); + if (!pp->change_colors) + { + if (pp->colors == COLORS_ONESIDED) + { + if (pp->display_mode == DISP_TRANSPARENT) + { + glUniform4fv(pp->front_ambient_index,1,mat_diff_trans_oneside); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_trans_oneside); + glUniform4fv(pp->back_ambient_index,1,mat_diff_trans_oneside); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_trans_oneside); + } + else if (pp->display_mode == DISP_SURFACE) + { + glUniform4fv(pp->front_ambient_index,1,mat_diff_oneside); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_oneside); + glUniform4fv(pp->back_ambient_index,1,mat_diff_oneside); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_oneside); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(pp->color_index,mat_diff_oneside); + } + } + else if (pp->colors == COLORS_TWOSIDED) + { + if (pp->display_mode == DISP_TRANSPARENT) + { + glUniform4fv(pp->front_ambient_index,1,mat_diff_trans_red); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_trans_red); + glUniform4fv(pp->back_ambient_index,1,mat_diff_trans_green); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_trans_green); + } + else if (pp->display_mode == DISP_SURFACE) + { + glUniform4fv(pp->front_ambient_index,1,mat_diff_red); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_red); + glUniform4fv(pp->back_ambient_index,1,mat_diff_green); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_green); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(pp->color_index,mat_diff_red); + } + } + } + else /* pp->change_colors */ + { + color(pp,0.0,matc,mat_diff_dyn); + if (pp->colors == COLORS_ONESIDED) + { + if (pp->display_mode == DISP_TRANSPARENT || + pp->display_mode == DISP_SURFACE) + { + glUniform4fv(pp->front_ambient_index,1,mat_diff_dyn); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_dyn); + glUniform4fv(pp->back_ambient_index,1,mat_diff_dyn); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_dyn); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(pp->color_index,mat_diff_dyn); + } + } + else if (pp->colors == COLORS_TWOSIDED) + { + if (pp->display_mode == DISP_TRANSPARENT || + pp->display_mode == DISP_SURFACE) + { + mat_diff_dyn_compl[0] = 1.0f-mat_diff_dyn[0]; + mat_diff_dyn_compl[1] = 1.0f-mat_diff_dyn[1]; + mat_diff_dyn_compl[2] = 1.0f-mat_diff_dyn[2]; + mat_diff_dyn_compl[3] = mat_diff_dyn[3]; + glUniform4fv(pp->front_ambient_index,1,mat_diff_dyn); + glUniform4fv(pp->front_diffuse_index,1,mat_diff_dyn); + glUniform4fv(pp->back_ambient_index,1,mat_diff_dyn_compl); + glUniform4fv(pp->back_diffuse_index,1,mat_diff_dyn_compl); + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(pp->color_index,mat_diff_dyn); + } + } + } + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D,pp->tex_name); + glUniform1i(pp->texture_sampler_index,0); + glUniform1i(pp->bool_textures_index,pp->marks); + + glEnableVertexAttribArray(pp->vertex_uv_index); + glBindBuffer(GL_ARRAY_BUFFER,pp->vertex_uv_buffer); + glVertexAttribPointer(pp->vertex_uv_index,2,GL_FLOAT,GL_FALSE,0,0); + + glEnableVertexAttribArray(pp->vertex_t_index); + glBindBuffer(GL_ARRAY_BUFFER,pp->vertex_t_buffer); + glVertexAttribPointer(pp->vertex_t_index,2,GL_FLOAT,GL_FALSE,0,0); + + if (pp->colors != COLORS_ONESIDED && pp->colors != COLORS_TWOSIDED) + { + glEnableVertexAttribArray(pp->color_index); + glBindBuffer(GL_ARRAY_BUFFER,pp->color_buffer); + if (pp->change_colors) + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + pp->col,GL_STREAM_DRAW); + glVertexAttribPointer(pp->color_index,4,GL_FLOAT,GL_FALSE,0,0); + } + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,pp->indices_buffer); + + if (pp->display_mode != DISP_WIREFRAME) + { + for (i=0; i<pp->ne; i++) + { + index_offset = pp->nt*i*sizeof(GLuint); + glDrawElements(GL_TRIANGLE_STRIP,pp->nt,GL_UNSIGNED_INT, + (const GLvoid *)index_offset); + } + } + else /* pp->display_mode == DISP_WIREFRAME */ + { + glLineWidth(1.0f); + index_offset = 0; + glDrawElements(GL_LINES,pp->ni,GL_UNSIGNED_INT, + (const void *)index_offset); + } + + glDisableVertexAttribArray(pp->vertex_uv_index); + glDisableVertexAttribArray(pp->vertex_t_index); + if (pp->colors != COLORS_ONESIDED && pp->colors != COLORS_TWOSIDED) + glDisableVertexAttribArray(pp->color_index); + glBindBuffer(GL_ARRAY_BUFFER,0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + + glUseProgram(0); + + polys = 2*NUMU*NUMV; + if (pp->appearance != APPEARANCE_SOLID) + polys /= 2; return polys; } +#endif /* HAVE_GLSL */ + /* Generate a texture image that shows the orientation reversal. */ static void gen_texture(ModeInfo *mi) { projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; + glPixelStorei(GL_UNPACK_ALIGNMENT,1); glGenTextures(1,&pp->tex_name); glBindTexture(GL_TEXTURE_2D,pp->tex_name); - glPixelStorei(GL_UNPACK_ALIGNMENT,1); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); @@ -1209,13 +2014,150 @@ static void gen_texture(ModeInfo *mi) } +#ifdef HAVE_GLSL + +static void init_glsl(ModeInfo *mi) +{ + projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; + GLint gl_major, gl_minor, glsl_major, glsl_minor; + GLboolean gl_gles3; + const GLchar *vertex_shader_source[3]; + const GLchar *fragment_shader_source[4]; + + /* Determine whether to use shaders to render the projective plane. */ + pp->use_shaders = False; + pp->buffers_initialized = False; + pp->shader_program = 0; + pp->ni = 0; + pp->ne = 0; + pp->nt = 0; + + if (!glsl_GetGlAndGlslVersions(&gl_major,&gl_minor,&glsl_major,&glsl_minor, + &gl_gles3)) + return; + if (!gl_gles3) + { + if (gl_major < 3 || + (glsl_major < 1 || (glsl_major == 1 && glsl_minor < 30))) + { + if ((gl_major < 2 || (gl_major == 2 && gl_minor < 1)) || + (glsl_major < 1 || (glsl_major == 1 && glsl_minor < 20))) + return; + /* We have at least OpenGL 2.1 and at least GLSL 1.20. */ + vertex_shader_source[0] = shader_version_2_1; + vertex_shader_source[1] = vertex_shader_attribs_2_1; + vertex_shader_source[2] = vertex_shader_main; + fragment_shader_source[0] = shader_version_2_1; + fragment_shader_source[1] = fragment_shader_attribs_2_1; + fragment_shader_source[2] = fragment_shader_main; + fragment_shader_source[3] = fragment_shader_out_2_1; + } + else + { + /* We have at least OpenGL 3.0 and at least GLSL 1.30. */ + vertex_shader_source[0] = shader_version_3_0; + vertex_shader_source[1] = vertex_shader_attribs_3_0; + vertex_shader_source[2] = vertex_shader_main; + fragment_shader_source[0] = shader_version_3_0; + fragment_shader_source[1] = fragment_shader_attribs_3_0; + fragment_shader_source[2] = fragment_shader_main; + fragment_shader_source[3] = fragment_shader_out_3_0; + } + } + else /* gl_gles3 */ + { + if (gl_major < 3 || glsl_major < 3) + return; + /* We have at least OpenGL ES 3.0 and at least GLSL ES 3.0. */ + vertex_shader_source[0] = shader_version_3_0_es; + vertex_shader_source[1] = vertex_shader_attribs_3_0; + vertex_shader_source[2] = vertex_shader_main; + fragment_shader_source[0] = shader_version_3_0_es; + fragment_shader_source[1] = fragment_shader_attribs_3_0; + fragment_shader_source[2] = fragment_shader_main; + fragment_shader_source[3] = fragment_shader_out_3_0; + } + if (!glsl_CompileAndLinkShaders(3,vertex_shader_source, + 4,fragment_shader_source, + &pp->shader_program)) + return; + pp->vertex_uv_index = glGetAttribLocation(pp->shader_program,"VertexUV"); + pp->vertex_t_index = glGetAttribLocation(pp->shader_program,"VertexT"); + pp->color_index = glGetAttribLocation(pp->shader_program,"VertexColor"); + if (pp->vertex_uv_index == -1 || pp->vertex_t_index == -1 || + pp->color_index == -1) + { + glDeleteProgram(pp->shader_program); + return; + } + pp->mat_rot_index = glGetUniformLocation(pp->shader_program, + "MatRot4D"); + pp->mat_p_index = glGetUniformLocation(pp->shader_program, + "MatProj"); + pp->bool_persp_index = glGetUniformLocation(pp->shader_program, + "BoolPersp"); + pp->off4d_index = glGetUniformLocation(pp->shader_program, + "Offset4D"); + pp->off3d_index = glGetUniformLocation(pp->shader_program, + "Offset3D"); + pp->bool_textures_index = glGetUniformLocation(pp->shader_program, + "BoolTextures"); + pp->draw_lines_index = glGetUniformLocation(pp->shader_program, + "DrawLines"); + pp->glbl_ambient_index = glGetUniformLocation(pp->shader_program, + "LtGlblAmbient"); + pp->lt_ambient_index = glGetUniformLocation(pp->shader_program, + "LtAmbient"); + pp->lt_diffuse_index = glGetUniformLocation(pp->shader_program, + "LtDiffuse"); + pp->lt_specular_index = glGetUniformLocation(pp->shader_program, + "LtSpecular"); + pp->lt_direction_index = glGetUniformLocation(pp->shader_program, + "LtDirection"); + pp->lt_halfvect_index = glGetUniformLocation(pp->shader_program, + "LtHalfVector"); + pp->front_ambient_index = glGetUniformLocation(pp->shader_program, + "MatFrontAmbient"); + pp->back_ambient_index = glGetUniformLocation(pp->shader_program, + "MatBackAmbient"); + pp->front_diffuse_index = glGetUniformLocation(pp->shader_program, + "MatFrontDiffuse"); + pp->back_diffuse_index = glGetUniformLocation(pp->shader_program, + "MatBackDiffuse"); + pp->specular_index = glGetUniformLocation(pp->shader_program, + "MatSpecular"); + pp->shininess_index = glGetUniformLocation(pp->shader_program, + "MatShininess"); + pp->texture_sampler_index = glGetUniformLocation(pp->shader_program, + "TextureSampler"); + if (pp->mat_rot_index == -1 || pp->mat_p_index == -1 || + pp->bool_persp_index == -1 || pp->off4d_index == -1 || + pp->off3d_index == -1 || pp->bool_textures_index == -1 || + pp->draw_lines_index == -1 || pp->glbl_ambient_index == -1 || + pp->lt_ambient_index == -1 || pp->lt_diffuse_index == -1 || + pp->lt_specular_index == -1 || pp->lt_direction_index == -1 || + pp->lt_halfvect_index == -1 || pp->front_ambient_index == -1 || + pp->back_ambient_index == -1 || pp->front_diffuse_index == -1 || + pp->back_diffuse_index == -1 || pp->specular_index == -1 || + pp->shininess_index == -1 || pp->texture_sampler_index == -1) + { + glDeleteProgram(pp->shader_program); + return; + } + + glGenBuffers(1,&pp->vertex_uv_buffer); + glGenBuffers(1,&pp->vertex_t_buffer); + glGenBuffers(1,&pp->color_buffer); + glGenBuffers(1,&pp->indices_buffer); + + pp->use_shaders = True; +} + +#endif /* HAVE_GLSL */ + + static void init(ModeInfo *mi) { - static const GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 }; - static const GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; - static const GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 }; - static const GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; - static const GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; if (walk_speed == 0.0) @@ -1265,78 +2207,16 @@ static void init(ModeInfo *mi) gen_texture(mi); setup_projective_plane(mi,0.0,2.0*M_PI,0.0,2.0*M_PI); - if (pp->marks) - glEnable(GL_TEXTURE_2D); - else - glDisable(GL_TEXTURE_2D); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - if (pp->projection_3d == DISP_3D_PERSPECTIVE || - pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) - { - if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) - gluPerspective(60.0,1.0,0.01,10.0); - else - gluPerspective(60.0,1.0,0.1,10.0); - } - else - { - glOrtho(-0.6,0.6,-0.6,0.6,0.1,10.0); - } - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); +#ifdef HAVE_GLSL + init_glsl(mi); +#endif /* HAVE_GLSL */ -# ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */ - if (pp->display_mode == DISP_WIREFRAME) +#ifdef HAVE_ANDROID + /* glPolygonMode(...,GL_LINE) is not supported for an OpenGL ES 1.1 + context. */ + if (!pp->use_shaders && pp->display_mode == DISP_WIREFRAME) pp->display_mode = DISP_SURFACE; -# endif - - if (pp->display_mode == DISP_SURFACE) - { - glEnable(GL_DEPTH_TEST); - glDepthFunc(GL_LESS); - glShadeModel(GL_SMOOTH); - glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); - glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); - glEnable(GL_LIGHTING); - glEnable(GL_LIGHT0); - glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient); - glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse); - glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular); - glLightfv(GL_LIGHT0,GL_POSITION,light_position); - glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular); - glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0); - glDepthMask(GL_TRUE); - glDisable(GL_BLEND); - } - else if (pp->display_mode == DISP_TRANSPARENT) - { - glDisable(GL_DEPTH_TEST); - glShadeModel(GL_SMOOTH); - glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); - glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE); - glEnable(GL_LIGHTING); - glEnable(GL_LIGHT0); - glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient); - glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse); - glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular); - glLightfv(GL_LIGHT0,GL_POSITION,light_position); - glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular); - glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0); - glDepthMask(GL_FALSE); - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA,GL_ONE); - } - else /* pp->display_mode == DISP_WIREFRAME */ - { - glDisable(GL_DEPTH_TEST); - glShadeModel(GL_FLAT); - glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); - glDisable(GL_LIGHTING); - glDisable(GL_LIGHT0); - glDisable(GL_BLEND); - } +#endif /* HAVE_ANDROID */ } @@ -1425,27 +2305,12 @@ static void display_projectiveplane(ModeInfo *mi) } } - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - if (pp->projection_3d == DISP_3D_PERSPECTIVE || - pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) - { - if (pp->view == VIEW_WALK || pp->view == VIEW_WALKTURN) - gluPerspective(60.0,pp->aspect,0.01,10.0); - else - gluPerspective(60.0,pp->aspect,0.1,10.0); - } +#ifdef HAVE_GLSL + if (pp->use_shaders) + mi->polygon_count = projective_plane_pf(mi,0.0,2.0*M_PI,0.0,2.0*M_PI); else - { - if (pp->aspect >= 1.0) - glOrtho(-0.6*pp->aspect,0.6*pp->aspect,-0.6,0.6,0.1,10.0); - else - glOrtho(-0.6,0.6,-0.6/pp->aspect,0.6/pp->aspect,0.1,10.0); - } - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - mi->polygon_count = projective_plane(mi,0.0,2.0*M_PI,0.0,2.0*M_PI); +#endif /* HAVE_GLSL */ + mi->polygon_count = projective_plane_ff(mi,0.0,2.0*M_PI,0.0,2.0*M_PI); } @@ -1541,7 +2406,6 @@ ENTRYPOINT void init_projectiveplane(ModeInfo *mi) MI_INIT(mi, projectiveplane); pp = &projectiveplane[MI_SCREEN(mi)]; - pp->trackballs[0] = gltrackball_init(True); pp->trackballs[1] = gltrackball_init(True); pp->current_trackball = 0; @@ -1711,7 +2575,6 @@ ENTRYPOINT void init_projectiveplane(ModeInfo *mi) if ((pp->glx_context = init_GL(mi)) != NULL) { reshape_projectiveplane(mi,MI_WIDTH(mi),MI_HEIGHT(mi)); - glDrawBuffer(GL_BACK); init(mi); } else @@ -1741,6 +2604,8 @@ ENTRYPOINT void draw_projectiveplane(ModeInfo *mi) glXMakeCurrent(display, window, *pp->glx_context); + glClearColor(0.0f,0.0f,0.0f,1.0f); + glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glLoadIdentity(); @@ -1768,6 +2633,7 @@ ENTRYPOINT void change_projectiveplane(ModeInfo *mi) } #endif /* !STANDALONE */ + ENTRYPOINT void free_projectiveplane(ModeInfo *mi) { projectiveplanestruct *pp = &projectiveplane[MI_SCREEN(mi)]; @@ -1776,8 +2642,23 @@ ENTRYPOINT void free_projectiveplane(ModeInfo *mi) gltrackball_free (pp->trackballs[0]); gltrackball_free (pp->trackballs[1]); if (pp->tex_name) glDeleteTextures (1, &pp->tex_name); +#ifdef HAVE_GLSL + if (pp->use_shaders) + { + glDeleteBuffers(1,&pp->vertex_uv_buffer); + glDeleteBuffers(1,&pp->vertex_t_buffer); + glDeleteBuffers(1,&pp->color_buffer); + glDeleteBuffers(1,&pp->indices_buffer); + if (pp->shader_program != 0) + { + glUseProgram(0); + glDeleteProgram(pp->shader_program); + } + } +#endif /* HAVE_GLSL */ } + XSCREENSAVER_MODULE ("ProjectivePlane", projectiveplane) #endif /* USE_GL */ |