diff options
Diffstat (limited to 'hacks/glx/hypertorus.c')
| -rw-r--r-- | hacks/glx/hypertorus.c | 990 |
1 files changed, 901 insertions, 89 deletions
diff --git a/hacks/glx/hypertorus.c b/hacks/glx/hypertorus.c index 41f4e0a..8adf5d7 100644 --- a/hacks/glx/hypertorus.c +++ b/hacks/glx/hypertorus.c @@ -1,10 +1,10 @@ /* hypertorus --- Shows a hypertorus that rotates in 4d */ #if 0 -static const char sccsid[] = "@(#)hypertorus.c 1.2 28/09/05 xlockmore"; +static const char sccsid[] = "@(#)hypertorus.c 1.2 05/09/28 xlockmore"; #endif -/* Copyright (c) 2003-2020 Carsten Steger <carsten@mirsanmir.org>. */ +/* Copyright (c) 2003-2021 Carsten Steger <carsten@mirsanmir.org>. */ /* * Permission to use, copy, modify, and distribute this software and its @@ -25,7 +25,12 @@ static const char sccsid[] = "@(#)hypertorus.c 1.2 28/09/05 xlockmore"; * and trackball support * C. Steger - 07/01/23: Improved 4d trackball support * C. Steger - 09/08/22: Removed check-config.pl warnings - * C. Steger - 11/01/20: Added the changing colors mode. + * C. Steger - 20/01/11: Added the changing colors mode + * C. Steger - 20/05/18: Added per-fragment shading + * C. Steger - 20/07/26: Make the shader code work under maxOS + * C. Steger - 20/11/19: Remove all unnecessary global variables + * 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 iOS */ /* @@ -100,10 +105,20 @@ static const char sccsid[] = "@(#)hypertorus.c 1.2 28/09/05 xlockmore"; #define DEF_SPEEDXZ "1.9" #define DEF_SPEEDYZ "2.1" + +/* For some strange reason, the color buffer must be initialized + and used on macOS. Otherwise one- and two-sided lighting will + not work. */ +#if (defined(HAVE_COCOA) || defined(__APPLE__)) && !defined(HAVE_IPHONE) +#define VERTEXATTRIBARRAY_WORKAROUND +#endif + + + #ifdef STANDALONE # define DEFAULTS "*delay: 25000 \n" \ "*showFPS: False \n" \ - "*suppressRotationAnimation: True\n" \ + "*prefersGLSL: True \n" \ # define release_hypertorus 0 # include "xlockmore.h" /* from the xscreensaver distribution */ @@ -113,6 +128,7 @@ static const char sccsid[] = "@(#)hypertorus.c 1.2 28/09/05 xlockmore"; #ifdef USE_GL +#include "glsl-utils.h" #include "gltrackball.h" @@ -123,7 +139,7 @@ ModStruct hypertorus_description = 25000, 1, 1, 1, 1.0, 4, "", "Shows a hypertorus rotating in 4d", 0, NULL}; -#endif +#endif /* USE_MODULES */ static char *mode; @@ -205,6 +221,9 @@ ENTRYPOINT ModeSpecOpt hypertorus_opts = #define DSIGMA 1.1 #define DTAU 1.7 +/* Number of subdivisions of the surface */ +#define NUMU 64 +#define NUMV 64 typedef struct { GLint WindH, WindW; @@ -220,11 +239,178 @@ typedef struct { int current_trackball; Bool button_pressed; float speed_scale; +#ifdef HAVE_GLSL + GLfloat uv[(NUMU+1)*(NUMV+1)][2]; + GLfloat col[(NUMU+1)*(NUMV+1)][4]; + GLuint indices[4*NUMU*NUMV]; + Bool use_shaders, buffers_initialized; + GLuint shader_program; + GLint vertex_uv_index, color_index; + GLint mat_rot_index, mat_p_index, bool_persp_index; + GLint off4d_index, off3d_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; + GLuint vertex_uv_buffer; + GLuint color_buffer, indices_buffer; + GLint ni, ne, nt; +#endif /* HAVE_GLSL */ } hypertorusstruct; static hypertorusstruct *hyper = (hypertorusstruct *) 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 VertexColor;\n" + "\n" + "varying vec3 Normal;\n" + "varying vec4 Color;\n" + "\n"; +static const GLchar *vertex_shader_attribs_3_0 = + "in vec2 VertexUV;\n" + "in vec4 VertexColor;\n" + "\n" + "out vec3 Normal;\n" + "out vec4 Color;\n" + "\n"; +static const GLchar *vertex_shader_main = + "uniform mat4 MatRot4D;\n" + "uniform mat4 MatProj;\n" + "uniform bool BoolPersp;\n" + "uniform vec4 Offset4D;\n" + "uniform vec4 Offset3D;\n" + "\n" + "void main (void)\n" + "{\n" + " vec3 p, pu, pv;\n" + " float su = sin(VertexUV.x)\n;" + " float cu = cos(VertexUV.x)\n;" + " float sv = sin(VertexUV.y)\n;" + " float cv = cos(VertexUV.y)\n;" + " vec4 xx = vec4(cu,su,cv,sv);" + " vec4 xxu = vec4(-su,cu,0.0,0.0);" + " vec4 xxv = vec4(0.0,0.0,-sv,cv);" + " 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/1.5f+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" + "}\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_glsl(). */ +static const GLchar *fragment_shader_attribs_2_1 = + "varying vec3 Normal;\n" + "varying vec4 Color;\n" + "\n"; +static const GLchar *fragment_shader_attribs_3_0 = + "in vec3 Normal;\n" + "in vec4 Color;\n" + "\n" + "out vec4 FragColor;\n" + "\n"; +static const GLchar *fragment_shader_main = + "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" + "\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" + " specularReflection);\n" + " }\n"; +static const GLchar *fragment_shader_out_2_1 = + " gl_FragColor = clamp(color,0.0,1.0);\n" + "}\n"; +static const GLchar *fragment_shader_out_3_0 = + " 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) { @@ -557,14 +743,20 @@ static void color(double angle, float mat[3][3], float col[4]) } -/* Draw a hypertorus projected into 3D. Note that the spirals appearance - will only work correctly if numu and numv are set to 64 or any higher - power of 2. Similarly, the banded appearance will only work correctly - if numu and numv are divisible by 4. */ -static int hypertorus(ModeInfo *mi, double umin, double umax, double vmin, - double vmax, int numu, int numv) +/* Draw a hypertorus projected into 3D using OpenGL's fixed + functionality. Note that the spirals appearance will only work + correctly if numu and numv are set to 64 or any higher power of 2. + Similarly, the banded appearance will only work correctly if numu + and numv are divisible by 4. */ +static int hypertorus_ff(ModeInfo *mi, double umin, double umax, double vmin, + double vmax, int numu, int numv) { - int polys = 0; + 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 }; @@ -580,6 +772,76 @@ static int hypertorus(ModeInfo *mi, double umin, double umax, double vmin, double r, s, t; float q1[4], q2[4], r1[4][4], r2[4][4]; hypertorusstruct *hp = &hyper[MI_SCREEN(mi)]; + int polys; + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + if (projection_3d == DISP_3D_ORTHOGRAPHIC) + { + if (hp->aspect >= 1.0) + glOrtho(-hp->aspect,hp->aspect,-1.0,1.0,0.1,10.0); + else + glOrtho(-1.0,1.0,-1.0/hp->aspect,1.0/hp->aspect,0.1,10.0); + } + else + { + gluPerspective(60.0,hp->aspect,0.1,10.0); + } + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + if (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); + glLightModelfv(GL_LIGHT_MODEL_AMBIENT,light_model_ambient); + glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_FALSE); + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR); + 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 (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); + glLightModelfv(GL_LIGHT_MODEL_AMBIENT,light_model_ambient); + glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_FALSE); + glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR); + 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 /* display_mode == DISP_WIREFRAME */ + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glShadeModel(GL_FLAT); + glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); + glDisable(GL_LIGHTING); + glDisable(GL_LIGHT0); + glDisable(GL_BLEND); + } if (change_colors) rotateall3d(hp->rho,hp->sigma,hp->tau,matc); @@ -659,7 +921,7 @@ static int hypertorus(ModeInfo *mi, double umin, double umax, double vmin, { for (k=0; k<=1; k++) { - l = (i+k); + l = i+k; m = j; u = ur*l/numu+umin; v = vr*m/numv+vmin; @@ -739,95 +1001,642 @@ static int hypertorus(ModeInfo *mi, double umin, double umax, double vmin, n[2] /= t; glNormal3fv(n); glVertex3fv(p); - polys++; } } glEnd(); } - polys /= 2; + + polys = 2*numu*numv; + if (appearance != APPEARANCE_SOLID) + polys /= 2; return polys; } -static void init(ModeInfo *mi) +#ifdef HAVE_GLSL + +/* Draw a hypertorus projected into 3D using OpenGL's programmable + functionality. Note that the spirals appearance will only work + correctly if numu and numv are set to 64 or any higher power of 2. + Similarly, the banded appearance will only work correctly if numu + and numv are divisible by 4. */ +static int hypertorus_pf(ModeInfo *mi, double umin, double umax, double vmin, + double vmax, int numu, int numv) { - 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 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, b, skew; + double u, v, ur, vr; + float q1[4], q2[4], r1[4][4], r2[4][4]; + GLsizeiptr index_offset; hypertorusstruct *hp = &hyper[MI_SCREEN(mi)]; + int polys; - hp->alpha = 0.0; - hp->beta = 0.0; - hp->delta = 0.0; - hp->zeta = 0.0; - hp->eta = 0.0; - hp->theta = 0.0; + if (!hp->use_shaders) + return 0; - hp->rho = frand(360.0); - hp->sigma = frand(360.0); - hp->tau = frand(360.0); + if (change_colors) + rotateall3d(hp->rho,hp->sigma,hp->tau,matc); - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - if (projection_3d == DISP_3D_PERSPECTIVE) - gluPerspective(60.0,1.0,0.1,100.0); - else - glOrtho(-1.0,1.0,-1.0,1.0,0.1,100.0);; - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); + rotateall(hp->alpha,hp->beta,hp->delta,hp->zeta,hp->eta,hp->theta,r1); -# ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */ - if (display_mode == DISP_WIREFRAME) - display_mode = DISP_SURFACE; -# endif + gltrackball_get_quaternion(hp->trackballs[0],q1); + gltrackball_get_quaternion(hp->trackballs[1],q2); + quats_to_rotmat(q1,q2,r2); + + mult_rotmat(r2,r1,mat); + + if (!hp->buffers_initialized) + { + /* The u and v values need to be computed once (or each time the value + of appearance changes, once we support that). */ + skew = num_spirals; + ur = umax-umin; + vr = vmax-vmin; + for (i=0; i<=numu; i++) + { + for (j=0; j<=numv; j++) + { + u = ur*i/numu+umin; + v = vr*j/numv+vmin; + o = i*(numv+1)+j; + if (appearance == APPEARANCE_SPIRALS) + u += 4.0*skew/numv*v; + hp->uv[o][0] = u; + hp->uv[o][1] = v; + } + } + glBindBuffer(GL_ARRAY_BUFFER,hp->vertex_uv_buffer); + glBufferData(GL_ARRAY_BUFFER,2*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + hp->uv,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + + if (!change_colors && colors == COLORS_COLORWHEEL) + { + for (i=0; i<=numu; i++) + { + for (j=0; j<=numv; j++) + { + u = ur*i/numu+umin; + v = vr*j/numv+vmin; + o = i*(numv+1)+j; + if (appearance == APPEARANCE_SPIRALS) + { + u += 4.0*skew/numv*v; + b = ((i/4)&(skew-1))*(numu/(4*skew)); + color(ur*4*b/numu+umin,matc,&hp->col[o][0]); + } + else + { + color(u,matc,&hp->col[o][0]); + } + } + } + glBindBuffer(GL_ARRAY_BUFFER,hp->color_buffer); + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + hp->col,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + } +#ifdef VERTEXATTRIBARRAY_WORKAROUND + if (colors != COLORS_COLORWHEEL) + { + for (i=0; i<=numu; i++) + { + for (j=0; j<=numv; j++) + { + o = i*(numv+1)+j; + if (display_mode == DISP_WIREFRAME) + { + if (colors == COLORS_ONESIDED) + { + for (k=0; k<4; k++) + hp->col[o][k] = mat_diff_oneside[k]; + } + else if (colors == COLORS_TWOSIDED) + { + for (k=0; k<4; k++) + hp->col[o][k] = mat_diff_red[k]; + } + } + else + { + for (k=0; k<4; k++) + hp->col[o][k] = mat_diff_white[k]; + } + } + } + glBindBuffer(GL_ARRAY_BUFFER,hp->color_buffer); + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + hp->col,GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER,0); + } +#endif /* VERTEXATTRIBARRAY_WORKAROUND */ + + /* The indices only need to be computed once (or each time the value + of appearance changes, once we support that). */ + hp->ne = 0; + hp->ni = 0; + hp->nt = 0; + if (display_mode != DISP_WIREFRAME) + { + for (i=0; i<numu; i++) + { + if ((appearance == APPEARANCE_BANDS || + appearance == APPEARANCE_SPIRALS) && ((i & 3) >= 2)) + continue; + for (j=0; j<=numv; j++) + { + for (k=0; k<=1; k++) + { + l = i+k; + m = j; + o = l*(numv+1)+m; + hp->indices[hp->ni++] = o; + } + } + hp->ne++; + } + hp->nt = 2*(numv+1); + } + else /* display_mode == DISP_WIREFRAME */ + { + for (i=0; i<numu; i++) + { + if ((appearance == APPEARANCE_BANDS || + appearance == APPEARANCE_SPIRALS) && ((i & 3) > 2)) + continue; + if ((appearance == APPEARANCE_BANDS || + appearance == APPEARANCE_SPIRALS) && ((i & 3) == 2)) + { + for (j=0; j<numv; j++) + { + hp->indices[hp->ni++] = i*(numv+1)+j; + hp->indices[hp->ni++] = i*(numv+1)+j+1; + } + continue; + } + for (j=0; j<numv; j++) + { + hp->indices[hp->ni++] = i*(numv+1)+j; + hp->indices[hp->ni++] = i*(numv+1)+j+1; + hp->indices[hp->ni++] = i*(numv+1)+j; + hp->indices[hp->ni++] = (i+1)*(numv+1)+j; + } + } + hp->ne = 1; + } + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,hp->indices_buffer); + glBufferData(GL_ELEMENT_ARRAY_BUFFER,hp->ni*sizeof(GLuint), + hp->indices,GL_STATIC_DRAW); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + hp->buffers_initialized = True; + } + + if (change_colors && colors == COLORS_COLORWHEEL) + { + skew = num_spirals; + ur = umax-umin; + vr = vmax-vmin; + for (i=0; i<=numu; i++) + { + for (j=0; j<=numv; j++) + { + u = ur*i/numu+umin; + v = vr*j/numv+vmin; + o = i*(numv+1)+j; + if (appearance == APPEARANCE_SPIRALS) + { + u += 4.0*skew/numv*v; + b = ((i/4)&(skew-1))*(numu/(4*skew)); + color(ur*4*b/numu+umin,matc,&hp->col[o][0]); + } + else + { + color(u,matc,&hp->col[o][0]); + } + } + } + } +#ifdef VERTEXATTRIBARRAY_WORKAROUND + else if (change_colors && colors != COLORS_COLORWHEEL) + { + if (display_mode == DISP_WIREFRAME) + { + color(0.0,matc,mat_diff_dyn); + for (i=0; i<=numu; i++) + { + for (j=0; j<=numv; j++) + { + o = i*(numv+1)+j; + for (k=0; k<4; k++) + hp->col[o][k] = mat_diff_dyn[k]; + } + } + } + } +#endif /* VERTEXATTRIBARRAY_WORKAROUND */ + + glUseProgram(hp->shader_program); + + glsl_Identity(p_mat); + if (projection_3d == DISP_3D_ORTHOGRAPHIC) + { + if (hp->aspect >= 1.0) + glsl_Orthographic(p_mat,-hp->aspect,hp->aspect,-1.0,1.0, + 0.1,10.0); + else + glsl_Orthographic(p_mat,-1.0,1.0,-1.0/hp->aspect,1.0/hp->aspect, + 0.1,10.0); + } + else + { + glsl_Perspective(p_mat,60.0f,hp->aspect,0.1f,10.0f); + } + glUniformMatrix4fv(hp->mat_rot_index,1,GL_TRUE,(GLfloat *)mat); + glUniformMatrix4fv(hp->mat_p_index,1,GL_FALSE,p_mat); + glUniform1i(hp->bool_persp_index,projection_4d == DISP_4D_PERSPECTIVE); + glUniform4fv(hp->off4d_index,1,offset4d); + glUniform4fv(hp->off3d_index,1,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 (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); + glUniform4fv(hp->glbl_ambient_index,1,light_model_ambient); + glUniform4fv(hp->lt_ambient_index,1,light_ambient); + glUniform4fv(hp->lt_diffuse_index,1,light_diffuse); + glUniform4fv(hp->lt_specular_index,1,light_specular); + glUniform3fv(hp->lt_direction_index,1,light_direction); + glUniform3fv(hp->lt_halfvect_index,1,half_vector); + glUniform4fv(hp->specular_index,1,mat_specular); + glUniform1f(hp->shininess_index,50.0f); + glUniform1i(hp->draw_lines_index,GL_FALSE); } else if (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); + glUniform4fv(hp->glbl_ambient_index,1,light_model_ambient); + glUniform4fv(hp->lt_ambient_index,1,light_ambient); + glUniform4fv(hp->lt_diffuse_index,1,light_diffuse); + glUniform4fv(hp->lt_specular_index,1,light_specular); + glUniform3fv(hp->lt_direction_index,1,light_direction); + glUniform3fv(hp->lt_halfvect_index,1,half_vector); + glUniform4fv(hp->specular_index,1,mat_specular); + glUniform1f(hp->shininess_index,50.0f); + glUniform1i(hp->draw_lines_index,GL_FALSE); } - else /* display_mode == DISP_WIREFRAME */ + else /* display_mode == DISP_WIREFRAME */ { - glDisable(GL_DEPTH_TEST); - glShadeModel(GL_FLAT); - glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); - glDisable(GL_LIGHTING); - glDisable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glDepthMask(GL_TRUE); glDisable(GL_BLEND); + glUniform1i(hp->draw_lines_index,GL_TRUE); } + + glUniform4fv(hp->front_ambient_index,1,mat_diff_white); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_white); + glUniform4fv(hp->back_ambient_index,1,mat_diff_white); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_white); + glVertexAttrib4f(hp->color_index,1.0f,1.0f,1.0f,1.0f); + if (!change_colors) + { + if (colors == COLORS_ONESIDED) + { + if (display_mode == DISP_TRANSPARENT) + { + glUniform4fv(hp->front_ambient_index,1,mat_diff_trans_oneside); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_trans_oneside); + glUniform4fv(hp->back_ambient_index,1,mat_diff_trans_oneside); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_trans_oneside); + } + else if (display_mode == DISP_SURFACE) + { + glUniform4fv(hp->front_ambient_index,1,mat_diff_oneside); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_oneside); + glUniform4fv(hp->back_ambient_index,1,mat_diff_oneside); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_oneside); + } + else /* display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(hp->color_index,mat_diff_oneside); + } + } + else if (colors == COLORS_TWOSIDED) + { + if (display_mode == DISP_TRANSPARENT) + { + glUniform4fv(hp->front_ambient_index,1,mat_diff_trans_red); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_trans_red); + glUniform4fv(hp->back_ambient_index,1,mat_diff_trans_green); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_trans_green); + } + else if (display_mode == DISP_SURFACE) + { + glUniform4fv(hp->front_ambient_index,1,mat_diff_red); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_red); + glUniform4fv(hp->back_ambient_index,1,mat_diff_green); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_green); + } + else /* display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(hp->color_index,mat_diff_red); + } + } + } + else /* change_colors */ + { + color(0.0,matc,mat_diff_dyn); + if (colors == COLORS_ONESIDED) + { + if (display_mode == DISP_TRANSPARENT || display_mode == DISP_SURFACE) + { + glUniform4fv(hp->front_ambient_index,1,mat_diff_dyn); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_dyn); + glUniform4fv(hp->back_ambient_index,1,mat_diff_dyn); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_dyn); + } + else /* display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(hp->color_index,mat_diff_dyn); + } + } + else if (colors == COLORS_TWOSIDED) + { + if (display_mode == DISP_TRANSPARENT || 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(hp->front_ambient_index,1,mat_diff_dyn); + glUniform4fv(hp->front_diffuse_index,1,mat_diff_dyn); + glUniform4fv(hp->back_ambient_index,1,mat_diff_dyn_compl); + glUniform4fv(hp->back_diffuse_index,1,mat_diff_dyn_compl); + } + else /* display_mode == DISP_WIREFRAME */ + { + glVertexAttrib4fv(hp->color_index,mat_diff_dyn); + } + } + } + + glEnableVertexAttribArray(hp->vertex_uv_index); + glBindBuffer(GL_ARRAY_BUFFER,hp->vertex_uv_buffer); + glVertexAttribPointer(hp->vertex_uv_index,2,GL_FLOAT,GL_FALSE,0,0); + + if (colors == COLORS_COLORWHEEL) + { + glEnableVertexAttribArray(hp->color_index); + glBindBuffer(GL_ARRAY_BUFFER,hp->color_buffer); + if (change_colors) + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + hp->col,GL_STREAM_DRAW); + glVertexAttribPointer(hp->color_index,4,GL_FLOAT,GL_FALSE,0,0); + } +#ifdef VERTEXATTRIBARRAY_WORKAROUND + else + { + glEnableVertexAttribArray(hp->color_index); + glBindBuffer(GL_ARRAY_BUFFER,hp->color_buffer); + if (change_colors) + glBufferData(GL_ARRAY_BUFFER,4*(NUMU+1)*(NUMV+1)*sizeof(GLfloat), + hp->col,GL_STREAM_DRAW); + glVertexAttribPointer(hp->color_index,4,GL_FLOAT,GL_FALSE,0,0); + } +#endif /* VERTEXATTRIBARRAY_WORKAROUND */ + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,hp->indices_buffer); + + if (display_mode != DISP_WIREFRAME) + { + for (i=0; i<hp->ne; i++) + { + index_offset = hp->nt*i*sizeof(GLuint); + glDrawElements(GL_TRIANGLE_STRIP,hp->nt,GL_UNSIGNED_INT, + (const void *)index_offset); + } + } + else /* display_mode == DISP_WIREFRAME */ + { + glLineWidth(1.0f); + index_offset = 0; + glDrawElements(GL_LINES,hp->ni,GL_UNSIGNED_INT, + (const void *)index_offset); + } + + glDisableVertexAttribArray(hp->vertex_uv_index); + if (colors == COLORS_COLORWHEEL) + glDisableVertexAttribArray(hp->color_index); +#ifdef VERTEXATTRIBARRAY_WORKAROUND + else + glDisableVertexAttribArray(hp->color_index); +#endif /* VERTEXATTRIBARRAY_WORKAROUND */ + glBindBuffer(GL_ARRAY_BUFFER,0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); + + glUseProgram(0); + + polys = 2*numu*numv; + if (appearance != APPEARANCE_SOLID) + polys /= 2; + return polys; +} + + +static void init_glsl(ModeInfo *mi) +{ + hypertorusstruct *hp = &hyper[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 hypertorus. */ + hp->use_shaders = False; + hp->buffers_initialized = False; + hp->shader_program = 0; + hp->ni = 0; + hp->ne = 0; + hp->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, + &hp->shader_program)) + return; + hp->vertex_uv_index = glGetAttribLocation(hp->shader_program,"VertexUV"); + hp->color_index = glGetAttribLocation(hp->shader_program,"VertexColor"); + if (hp->vertex_uv_index == -1 || hp->color_index == -1) + { + glDeleteProgram(hp->shader_program); + return; + } + hp->mat_rot_index = glGetUniformLocation(hp->shader_program, + "MatRot4D"); + hp->mat_p_index = glGetUniformLocation(hp->shader_program, + "MatProj"); + hp->bool_persp_index = glGetUniformLocation(hp->shader_program, + "BoolPersp"); + hp->off4d_index = glGetUniformLocation(hp->shader_program, + "Offset4D"); + hp->off3d_index = glGetUniformLocation(hp->shader_program, + "Offset3D"); + hp->draw_lines_index = glGetUniformLocation(hp->shader_program, + "DrawLines"); + hp->glbl_ambient_index = glGetUniformLocation(hp->shader_program, + "LtGlblAmbient"); + hp->lt_ambient_index = glGetUniformLocation(hp->shader_program, + "LtAmbient"); + hp->lt_diffuse_index = glGetUniformLocation(hp->shader_program, + "LtDiffuse"); + hp->lt_specular_index = glGetUniformLocation(hp->shader_program, + "LtSpecular"); + hp->lt_direction_index = glGetUniformLocation(hp->shader_program, + "LtDirection"); + hp->lt_halfvect_index = glGetUniformLocation(hp->shader_program, + "LtHalfVector"); + hp->front_ambient_index = glGetUniformLocation(hp->shader_program, + "MatFrontAmbient"); + hp->back_ambient_index = glGetUniformLocation(hp->shader_program, + "MatBackAmbient"); + hp->front_diffuse_index = glGetUniformLocation(hp->shader_program, + "MatFrontDiffuse"); + hp->back_diffuse_index = glGetUniformLocation(hp->shader_program, + "MatBackDiffuse"); + hp->specular_index = glGetUniformLocation(hp->shader_program, + "MatSpecular"); + hp->shininess_index = glGetUniformLocation(hp->shader_program, + "MatShininess"); + if (hp->mat_rot_index == -1 || hp->mat_p_index == -1 || + hp->bool_persp_index == -1 || hp->off4d_index == -1 || + hp->off3d_index == -1 || hp->draw_lines_index == -1 || + hp->glbl_ambient_index == -1 || hp->lt_ambient_index == -1 || + hp->lt_diffuse_index == -1 || hp->lt_specular_index == -1 || + hp->lt_direction_index == -1 || hp->lt_halfvect_index == -1 || + hp->specular_index == -1 || hp->shininess_index == -1 || + hp->front_ambient_index == -1 || hp->back_ambient_index == -1 || + hp->front_diffuse_index == -1 || hp->back_diffuse_index == -1) + { + glDeleteProgram(hp->shader_program); + return; + } + + glGenBuffers(1,&hp->vertex_uv_buffer); + glGenBuffers(1,&hp->color_buffer); + glGenBuffers(1,&hp->indices_buffer); + + hp->use_shaders = True; +} + +#endif /* HAVE_GLSL */ + + +static void init(ModeInfo *mi) +{ + hypertorusstruct *hp = &hyper[MI_SCREEN(mi)]; + + hp->alpha = 0.0; + hp->beta = 0.0; + hp->delta = 0.0; + hp->zeta = 0.0; + hp->eta = 0.0; + hp->theta = 0.0; + + hp->rho = frand(360.0); + hp->sigma = frand(360.0); + hp->tau = frand(360.0); + +#ifdef HAVE_GLSL + init_glsl(mi); +#endif /* HAVE_GLSL */ + +#ifdef HAVE_ANDROID + /* glPolygonMode(...,GL_LINE) is not supported for an OpenGL ES 1.1 + context. */ + if (!hp->use_shaders && display_mode == DISP_WIREFRAME) + display_mode = DISP_SURFACE; +#endif /* HAVE_ANDROID */ } @@ -871,23 +1680,12 @@ static void display_hypertorus(ModeInfo *mi) } } - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - if (projection_3d == DISP_3D_ORTHOGRAPHIC) - { - if (hp->aspect >= 1.0) - glOrtho(-hp->aspect,hp->aspect,-1.0,1.0,0.1,100.0); - else - glOrtho(-1.0,1.0,-1.0/hp->aspect,1.0/hp->aspect,0.1,100.0); - } +#ifdef HAVE_GLSL + if (hp->use_shaders) + mi->polygon_count = hypertorus_pf(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,NUMU,NUMV); else - { - gluPerspective(60.0,hp->aspect,0.1,100.0); - } - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - mi->polygon_count = hypertorus(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,64,64); +#endif /* HAVE_GLSL */ + mi->polygon_count = hypertorus_ff(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,NUMU,NUMV); } @@ -983,7 +1781,6 @@ ENTRYPOINT void init_hypertorus(ModeInfo *mi) MI_INIT(mi, hyper); hp = &hyper[MI_SCREEN(mi)]; - hp->trackballs[0] = gltrackball_init(True); hp->trackballs[1] = gltrackball_init(True); hp->current_trackball = 0; @@ -1100,7 +1897,6 @@ ENTRYPOINT void init_hypertorus(ModeInfo *mi) if ((hp->glx_context = init_GL(mi)) != NULL) { reshape_hypertorus(mi,MI_WIDTH(mi),MI_HEIGHT(mi)); - glDrawBuffer(GL_BACK); init(mi); } else @@ -1130,8 +1926,9 @@ ENTRYPOINT void draw_hypertorus(ModeInfo *mi) glXMakeCurrent(display, window, *hp->glx_context); + glClearColor(0.0f,0.0f,0.0f,1.0f); + glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); - glLoadIdentity(); display_hypertorus(mi); @@ -1157,6 +1954,7 @@ ENTRYPOINT void change_hypertorus(ModeInfo *mi) } #endif /* !STANDALONE */ + ENTRYPOINT void free_hypertorus(ModeInfo *mi) { hypertorusstruct *hp = &hyper[MI_SCREEN(mi)]; @@ -1164,8 +1962,22 @@ ENTRYPOINT void free_hypertorus(ModeInfo *mi) glXMakeCurrent (MI_DISPLAY(mi), MI_WINDOW(mi), *hp->glx_context); gltrackball_free (hp->trackballs[0]); gltrackball_free (hp->trackballs[1]); +#ifdef HAVE_GLSL + if (hp->use_shaders) + { + glDeleteBuffers(1,&hp->vertex_uv_buffer); + glDeleteBuffers(1,&hp->color_buffer); + glDeleteBuffers(1,&hp->indices_buffer); + if (hp->shader_program != 0) + { + glUseProgram(0); + glDeleteProgram(hp->shader_program); + } + } +#endif /* HAVE_GLSL */ } + XSCREENSAVER_MODULE ("Hypertorus", hypertorus) #endif /* USE_GL */ |