Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 1 | /* |
| 2 | * GL_ARB_texture_cube_map demo |
| 3 | * |
| 4 | * Brian Paul |
| 5 | * May 2000 |
| 6 | * |
| 7 | * |
| 8 | * Copyright (C) 2000 Brian Paul All Rights Reserved. |
| 9 | * |
| 10 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 11 | * copy of this software and associated documentation files (the "Software"), |
| 12 | * to deal in the Software without restriction, including without limitation |
| 13 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 14 | * and/or sell copies of the Software, and to permit persons to whom the |
| 15 | * Software is furnished to do so, subject to the following conditions: |
| 16 | * |
| 17 | * The above copyright notice and this permission notice shall be included |
| 18 | * in all copies or substantial portions of the Software. |
| 19 | * |
| 20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| 21 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 23 | * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN |
| 24 | * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| 25 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 26 | */ |
| 27 | |
| 28 | |
| 29 | /* |
| 30 | * This is a pretty minimalistic demo for now. Eventually, use some |
| 31 | * interesting cube map textures and 3D objects. |
| 32 | * For now, we use 6 checkerboard "walls" and a sphere (good for |
| 33 | * verification purposes). |
| 34 | */ |
| 35 | |
| 36 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 37 | #include <assert.h> |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 38 | #include <math.h> |
Brian Paul | 02e8a03 | 2000-06-27 17:04:43 +0000 | [diff] [blame] | 39 | #include <stdio.h> |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 40 | #include <stdlib.h> |
| 41 | #include <string.h> |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 42 | #include <GL/glew.h> |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 43 | #include "GL/glut.h" |
Brian Paul | 0fe7f40 | 2005-01-09 17:06:22 +0000 | [diff] [blame] | 44 | #include "readtex.h" |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 45 | |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 46 | #ifndef GL_TEXTURE_CUBE_MAP_SEAMLESS |
| 47 | #define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F |
| 48 | #endif |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 49 | |
| 50 | static GLfloat Xrot = 0, Yrot = 0; |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 51 | static GLfloat EyeDist = 10; |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 52 | static GLboolean use_vertex_arrays = GL_FALSE; |
Brian Paul | 52a5cc0 | 2004-08-10 15:39:00 +0000 | [diff] [blame] | 53 | static GLboolean anim = GL_TRUE; |
Brian | 3a484cd | 2007-08-27 12:00:19 -0600 | [diff] [blame] | 54 | static GLboolean NoClear = GL_FALSE; |
| 55 | static GLint FrameParity = 0; |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 56 | static GLenum FilterIndex = 0; |
| 57 | static GLint ClampIndex = 0; |
Roland Scheidegger | 7a5c5b9 | 2009-06-20 00:24:03 +0200 | [diff] [blame] | 58 | static GLboolean supportFBO = GL_FALSE; |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 59 | static GLboolean supportSeamless = GL_FALSE; |
| 60 | static GLboolean seamless = GL_FALSE; |
Brian Paul | 0b0fc40 | 2009-09-15 17:13:49 -0600 | [diff] [blame] | 61 | static GLuint TexObj = 0; |
Keith Whitwell | 75312b6 | 2009-08-23 19:02:17 +0100 | [diff] [blame] | 62 | static GLint T0 = 0; |
| 63 | static GLint Frames = 0; |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 64 | |
| 65 | |
| 66 | static struct { |
| 67 | GLenum mode; |
| 68 | const char *name; |
| 69 | } ClampModes[] = { |
| 70 | { GL_CLAMP_TO_EDGE, "GL_CLAMP_TO_EDGE" }, |
| 71 | { GL_CLAMP_TO_BORDER, "GL_CLAMP_TO_BORDER" }, |
| 72 | { GL_CLAMP, "GL_CLAMP" }, |
| 73 | { GL_REPEAT, "GL_REPEAT" } |
| 74 | }; |
| 75 | |
| 76 | #define NUM_CLAMP_MODES (sizeof(ClampModes) / sizeof(ClampModes[0])) |
| 77 | |
| 78 | |
| 79 | static struct { |
| 80 | GLenum mag_mode, min_mode; |
| 81 | const char *name; |
| 82 | } FilterModes[] = { |
| 83 | { GL_NEAREST, GL_NEAREST, "GL_NEAREST, GL_NEAREST" }, |
| 84 | { GL_NEAREST, GL_LINEAR, "GL_NEAREST, GL_LINEAR" }, |
| 85 | { GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, "GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST" }, |
| 86 | { GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR, "GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR" }, |
| 87 | { GL_NEAREST, GL_LINEAR_MIPMAP_NEAREST, "GL_NEAREST, GL_LINEAR_MIPMAP_NEAREST" }, |
| 88 | { GL_NEAREST, GL_LINEAR_MIPMAP_LINEAR, "GL_NEAREST, GL_LINEAR_MIPMAP_LINEAR" }, |
| 89 | |
| 90 | { GL_LINEAR, GL_NEAREST, "GL_LINEAR, GL_NEAREST" }, |
| 91 | { GL_LINEAR, GL_LINEAR, "GL_LINEAR, GL_LINEAR" }, |
| 92 | { GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, "GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST" }, |
| 93 | { GL_LINEAR, GL_NEAREST_MIPMAP_LINEAR, "GL_LINEAR, GL_NEAREST_MIPMAP_LINEAR" }, |
| 94 | { GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, "GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST" }, |
| 95 | { GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, "GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR" } |
| 96 | }; |
| 97 | |
| 98 | #define NUM_FILTER_MODES (sizeof(FilterModes) / sizeof(FilterModes[0])) |
| 99 | |
| 100 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 101 | |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 102 | /* The effects of GL_ARB_seamless_cube_map don't show up unless eps1 is 1.0. |
| 103 | */ |
| 104 | #define eps1 1.0 /*0.99*/ |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 105 | #define br 20.0 /* box radius */ |
| 106 | |
| 107 | static const GLfloat tex_coords[] = { |
| 108 | /* +X side */ |
| 109 | 1.0, -eps1, -eps1, |
| 110 | 1.0, -eps1, eps1, |
| 111 | 1.0, eps1, eps1, |
| 112 | 1.0, eps1, -eps1, |
| 113 | |
| 114 | /* -X side */ |
| 115 | -1.0, eps1, -eps1, |
| 116 | -1.0, eps1, eps1, |
| 117 | -1.0, -eps1, eps1, |
| 118 | -1.0, -eps1, -eps1, |
| 119 | |
| 120 | /* +Y side */ |
| 121 | -eps1, 1.0, -eps1, |
| 122 | -eps1, 1.0, eps1, |
| 123 | eps1, 1.0, eps1, |
| 124 | eps1, 1.0, -eps1, |
| 125 | |
| 126 | /* -Y side */ |
| 127 | -eps1, -1.0, -eps1, |
| 128 | -eps1, -1.0, eps1, |
| 129 | eps1, -1.0, eps1, |
| 130 | eps1, -1.0, -eps1, |
| 131 | |
| 132 | /* +Z side */ |
| 133 | eps1, -eps1, 1.0, |
| 134 | -eps1, -eps1, 1.0, |
| 135 | -eps1, eps1, 1.0, |
| 136 | eps1, eps1, 1.0, |
| 137 | |
| 138 | /* -Z side */ |
| 139 | eps1, eps1, -1.0, |
| 140 | -eps1, eps1, -1.0, |
| 141 | -eps1, -eps1, -1.0, |
| 142 | eps1, -eps1, -1.0, |
| 143 | }; |
| 144 | |
| 145 | static const GLfloat vtx_coords[] = { |
| 146 | /* +X side */ |
| 147 | br, -br, -br, |
| 148 | br, -br, br, |
| 149 | br, br, br, |
| 150 | br, br, -br, |
| 151 | |
| 152 | /* -X side */ |
| 153 | -br, br, -br, |
| 154 | -br, br, br, |
| 155 | -br, -br, br, |
| 156 | -br, -br, -br, |
| 157 | |
| 158 | /* +Y side */ |
| 159 | -br, br, -br, |
| 160 | -br, br, br, |
| 161 | br, br, br, |
| 162 | br, br, -br, |
| 163 | |
| 164 | /* -Y side */ |
| 165 | -br, -br, -br, |
| 166 | -br, -br, br, |
| 167 | br, -br, br, |
| 168 | br, -br, -br, |
| 169 | |
| 170 | /* +Z side */ |
| 171 | br, -br, br, |
| 172 | -br, -br, br, |
| 173 | -br, br, br, |
| 174 | br, br, br, |
| 175 | |
| 176 | /* -Z side */ |
| 177 | br, br, -br, |
| 178 | -br, br, -br, |
| 179 | -br, -br, -br, |
| 180 | br, -br, -br, |
| 181 | }; |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 182 | |
| 183 | static void draw_skybox( void ) |
| 184 | { |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 185 | if ( use_vertex_arrays ) { |
| 186 | glTexCoordPointer( 3, GL_FLOAT, 0, tex_coords ); |
| 187 | glVertexPointer( 3, GL_FLOAT, 0, vtx_coords ); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 188 | |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 189 | glEnableClientState( GL_TEXTURE_COORD_ARRAY ); |
| 190 | glEnableClientState( GL_VERTEX_ARRAY ); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 191 | |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 192 | glDrawArrays( GL_QUADS, 0, 24 ); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 193 | |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 194 | glDisableClientState( GL_TEXTURE_COORD_ARRAY ); |
| 195 | glDisableClientState( GL_VERTEX_ARRAY ); |
| 196 | } |
| 197 | else { |
| 198 | unsigned i; |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 199 | |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 200 | glBegin(GL_QUADS); |
| 201 | for ( i = 0 ; i < 24 ; i++ ) { |
| 202 | glTexCoord3fv( & tex_coords[ i * 3 ] ); |
| 203 | glVertex3fv ( & vtx_coords[ i * 3 ] ); |
| 204 | } |
| 205 | glEnd(); |
| 206 | } |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 207 | } |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 208 | |
| 209 | |
| 210 | static void draw( void ) |
| 211 | { |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 212 | GLenum wrap; |
| 213 | |
Brian | 3a484cd | 2007-08-27 12:00:19 -0600 | [diff] [blame] | 214 | if (NoClear) { |
| 215 | /* This demonstrates how we can avoid calling glClear. |
| 216 | * This method only works if every pixel in the window is painted for |
| 217 | * every frame. |
| 218 | * We can simply skip clearing of the color buffer in this case. |
| 219 | * For the depth buffer, we alternately use a different subrange of |
| 220 | * the depth buffer for each frame. For the odd frame use the range |
| 221 | * [0, 0.5] with GL_LESS. For the even frames, use the range [1, 0.5] |
| 222 | * with GL_GREATER. |
| 223 | */ |
| 224 | FrameParity = 1 - FrameParity; |
| 225 | if (FrameParity) { |
| 226 | glDepthRange(0.0, 0.5); |
| 227 | glDepthFunc(GL_LESS); |
| 228 | } |
| 229 | else { |
| 230 | glDepthRange(1.0, 0.5); |
| 231 | glDepthFunc(GL_GREATER); |
| 232 | } |
| 233 | } |
| 234 | else { |
| 235 | /* ordinary clearing */ |
| 236 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
| 237 | } |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 238 | |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 239 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, |
| 240 | FilterModes[FilterIndex].min_mode); |
| 241 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, |
| 242 | FilterModes[FilterIndex].mag_mode); |
| 243 | |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 244 | if (supportSeamless) { |
| 245 | if (seamless) { |
| 246 | glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); |
| 247 | } else { |
| 248 | glDisable(GL_TEXTURE_CUBE_MAP_SEAMLESS); |
| 249 | } |
| 250 | } |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 251 | wrap = ClampModes[ClampIndex].mode; |
| 252 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, wrap); |
| 253 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, wrap); |
| 254 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, wrap); |
| 255 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 256 | glPushMatrix(); /*MODELVIEW*/ |
| 257 | glTranslatef( 0.0, 0.0, -EyeDist ); |
| 258 | |
| 259 | /* skybox */ |
| 260 | glDisable(GL_TEXTURE_GEN_S); |
| 261 | glDisable(GL_TEXTURE_GEN_T); |
| 262 | glDisable(GL_TEXTURE_GEN_R); |
| 263 | |
| 264 | glMatrixMode(GL_MODELVIEW); |
| 265 | glPushMatrix(); |
| 266 | glRotatef(Xrot, 1, 0, 0); |
| 267 | glRotatef(Yrot, 0, 1, 0); |
| 268 | draw_skybox(); |
| 269 | glPopMatrix(); |
| 270 | |
| 271 | /* sphere */ |
| 272 | glMatrixMode(GL_TEXTURE); |
| 273 | glLoadIdentity(); |
| 274 | glRotatef(-Yrot, 0, 1, 0); |
| 275 | glRotatef(-Xrot, 1, 0, 0); |
| 276 | |
| 277 | glEnable(GL_TEXTURE_GEN_S); |
| 278 | glEnable(GL_TEXTURE_GEN_T); |
| 279 | glEnable(GL_TEXTURE_GEN_R); |
| 280 | glutSolidSphere(2.0, 20, 20); |
| 281 | |
| 282 | glLoadIdentity(); /* texture */ |
| 283 | |
| 284 | glMatrixMode(GL_MODELVIEW); |
| 285 | glPopMatrix(); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 286 | |
| 287 | glutSwapBuffers(); |
Keith Whitwell | 75312b6 | 2009-08-23 19:02:17 +0100 | [diff] [blame] | 288 | |
| 289 | Frames++; |
| 290 | |
| 291 | { |
| 292 | GLint t = glutGet(GLUT_ELAPSED_TIME); |
| 293 | if (t - T0 >= 5000) { |
| 294 | GLfloat seconds = (t - T0) / 1000.0; |
| 295 | GLfloat fps = Frames / seconds; |
| 296 | printf("%d frames in %6.3f seconds = %6.3f FPS\n", Frames, seconds, fps); |
| 297 | fflush(stdout); |
| 298 | T0 = t; |
| 299 | Frames = 0; |
| 300 | } |
| 301 | } |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 302 | } |
| 303 | |
| 304 | |
| 305 | static void idle(void) |
| 306 | { |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 307 | GLfloat t = 0.05 * glutGet(GLUT_ELAPSED_TIME); |
| 308 | Yrot = t; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 309 | glutPostRedisplay(); |
| 310 | } |
| 311 | |
| 312 | |
| 313 | static void set_mode(GLuint mode) |
| 314 | { |
| 315 | if (mode == 0) { |
| 316 | glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); |
| 317 | glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); |
| 318 | glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB); |
| 319 | printf("GL_REFLECTION_MAP_ARB mode\n"); |
| 320 | } |
| 321 | else if (mode == 1) { |
| 322 | glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB); |
| 323 | glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB); |
| 324 | glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB); |
| 325 | printf("GL_NORMAL_MAP_ARB mode\n"); |
| 326 | } |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 327 | } |
| 328 | |
| 329 | |
| 330 | static void key(unsigned char k, int x, int y) |
| 331 | { |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 332 | static GLuint mode = 0; |
| 333 | (void) x; |
| 334 | (void) y; |
| 335 | switch (k) { |
| 336 | case ' ': |
| 337 | anim = !anim; |
| 338 | if (anim) |
| 339 | glutIdleFunc(idle); |
| 340 | else |
| 341 | glutIdleFunc(NULL); |
| 342 | break; |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 343 | case 'f': |
| 344 | FilterIndex = (FilterIndex + 1) % NUM_FILTER_MODES; |
| 345 | printf("Tex filter: %s\n", FilterModes[FilterIndex].name); |
| 346 | break; |
| 347 | case 'c': |
| 348 | ClampIndex = (ClampIndex + 1) % NUM_CLAMP_MODES; |
| 349 | printf("Tex wrap mode: %s\n", ClampModes[ClampIndex].name); |
| 350 | break; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 351 | case 'm': |
| 352 | mode = !mode; |
| 353 | set_mode(mode); |
| 354 | break; |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 355 | case 's': |
| 356 | seamless = ! seamless; |
| 357 | printf("Seamless cube map filtering is %sabled\n", |
| 358 | (seamless) ? "en" : "dis" ); |
| 359 | break; |
Ian Romanick | cd6ca58 | 2004-05-05 20:17:19 +0000 | [diff] [blame] | 360 | case 'v': |
| 361 | use_vertex_arrays = ! use_vertex_arrays; |
| 362 | printf( "Vertex arrays are %sabled\n", |
| 363 | (use_vertex_arrays) ? "en" : "dis" ); |
| 364 | break; |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 365 | case 'z': |
| 366 | EyeDist -= 0.5; |
| 367 | if (EyeDist < 6.0) |
| 368 | EyeDist = 6.0; |
| 369 | break; |
| 370 | case 'Z': |
| 371 | EyeDist += 0.5; |
| 372 | if (EyeDist > 90.0) |
| 373 | EyeDist = 90; |
| 374 | break; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 375 | case 27: |
| 376 | exit(0); |
| 377 | } |
| 378 | glutPostRedisplay(); |
| 379 | } |
| 380 | |
| 381 | |
| 382 | static void specialkey(int key, int x, int y) |
| 383 | { |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 384 | GLfloat step = 5; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 385 | (void) x; |
| 386 | (void) y; |
| 387 | switch (key) { |
| 388 | case GLUT_KEY_UP: |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 389 | Xrot += step; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 390 | break; |
| 391 | case GLUT_KEY_DOWN: |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 392 | Xrot -= step; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 393 | break; |
| 394 | case GLUT_KEY_LEFT: |
| 395 | Yrot -= step; |
| 396 | break; |
| 397 | case GLUT_KEY_RIGHT: |
| 398 | Yrot += step; |
| 399 | break; |
| 400 | } |
| 401 | glutPostRedisplay(); |
| 402 | } |
| 403 | |
| 404 | |
| 405 | /* new window size or exposure */ |
| 406 | static void reshape(int width, int height) |
| 407 | { |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 408 | GLfloat ar = (float) width / (float) height; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 409 | glViewport(0, 0, (GLint)width, (GLint)height); |
| 410 | glMatrixMode(GL_PROJECTION); |
| 411 | glLoadIdentity(); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 412 | glFrustum( -2.0*ar, 2.0*ar, -2.0, 2.0, 4.0, 100.0 ); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 413 | glMatrixMode(GL_MODELVIEW); |
| 414 | glLoadIdentity(); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 418 | static void init_checkers( void ) |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 419 | { |
| 420 | #define CUBE_TEX_SIZE 64 |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 421 | GLubyte image[CUBE_TEX_SIZE][CUBE_TEX_SIZE][4]; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 422 | static const GLubyte colors[6][3] = { |
Keith Whitwell | 493e6e1 | 2004-02-05 17:36:02 +0000 | [diff] [blame] | 423 | { 255, 0, 0 }, /* face 0 - red */ |
| 424 | { 0, 255, 255 }, /* face 1 - cyan */ |
| 425 | { 0, 255, 0 }, /* face 2 - green */ |
| 426 | { 255, 0, 255 }, /* face 3 - purple */ |
| 427 | { 0, 0, 255 }, /* face 4 - blue */ |
| 428 | { 255, 255, 0 } /* face 5 - yellow */ |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 429 | }; |
| 430 | static const GLenum targets[6] = { |
| 431 | GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, |
| 432 | GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, |
| 433 | GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, |
| 434 | GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, |
| 435 | GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, |
| 436 | GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB |
| 437 | }; |
| 438 | |
| 439 | GLint i, j, f; |
| 440 | |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 441 | glPixelStorei(GL_UNPACK_ALIGNMENT, 1); |
| 442 | |
Roland Scheidegger | 7a5c5b9 | 2009-06-20 00:24:03 +0200 | [diff] [blame] | 443 | if (!supportFBO) |
| 444 | glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); |
| 445 | |
| 446 | |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 447 | /* make colored checkerboard cube faces */ |
| 448 | for (f = 0; f < 6; f++) { |
| 449 | for (i = 0; i < CUBE_TEX_SIZE; i++) { |
| 450 | for (j = 0; j < CUBE_TEX_SIZE; j++) { |
| 451 | if ((i/4 + j/4) & 1) { |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 452 | image[i][j][0] = colors[f][2]; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 453 | image[i][j][1] = colors[f][1]; |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 454 | image[i][j][2] = colors[f][0]; |
| 455 | image[i][j][3] = 255; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 456 | } |
| 457 | else { |
| 458 | image[i][j][0] = 255; |
| 459 | image[i][j][1] = 255; |
| 460 | image[i][j][2] = 255; |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 461 | image[i][j][3] = 255; |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 462 | } |
| 463 | } |
| 464 | } |
| 465 | |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 466 | glTexImage2D(targets[f], 0, GL_RGBA8, CUBE_TEX_SIZE, CUBE_TEX_SIZE, 0, |
| 467 | GL_BGRA, GL_UNSIGNED_BYTE, image); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 468 | } |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 469 | |
Roland Scheidegger | 7a5c5b9 | 2009-06-20 00:24:03 +0200 | [diff] [blame] | 470 | if (supportFBO) |
| 471 | glGenerateMipmapEXT(GL_TEXTURE_CUBE_MAP_ARB); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 472 | } |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 473 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 474 | |
| 475 | static void load(GLenum target, const char *filename, |
| 476 | GLboolean flipTB, GLboolean flipLR) |
| 477 | { |
| 478 | GLint w, h; |
| 479 | GLenum format; |
| 480 | GLubyte *img = LoadRGBImage( filename, &w, &h, &format ); |
| 481 | if (!img) { |
| 482 | printf("Error: couldn't load texture image %s\n", filename); |
| 483 | exit(1); |
| 484 | } |
| 485 | assert(format == GL_RGB); |
| 486 | |
| 487 | /* <sigh> the way the texture cube mapping works, we have to flip |
| 488 | * images to make things look right. |
| 489 | */ |
| 490 | if (flipTB) { |
| 491 | const int stride = 3 * w; |
| 492 | GLubyte temp[3*1024]; |
| 493 | int i; |
| 494 | for (i = 0; i < h / 2; i++) { |
| 495 | memcpy(temp, img + i * stride, stride); |
| 496 | memcpy(img + i * stride, img + (h - i - 1) * stride, stride); |
| 497 | memcpy(img + (h - i - 1) * stride, temp, stride); |
| 498 | } |
| 499 | } |
| 500 | if (flipLR) { |
| 501 | const int stride = 3 * w; |
| 502 | GLubyte temp[3]; |
| 503 | GLubyte *row; |
| 504 | int i, j; |
| 505 | for (i = 0; i < h; i++) { |
| 506 | row = img + i * stride; |
| 507 | for (j = 0; j < w / 2; j++) { |
| 508 | int k = w - j - 1; |
| 509 | temp[0] = row[j*3+0]; |
| 510 | temp[1] = row[j*3+1]; |
| 511 | temp[2] = row[j*3+2]; |
| 512 | row[j*3+0] = row[k*3+0]; |
| 513 | row[j*3+1] = row[k*3+1]; |
| 514 | row[j*3+2] = row[k*3+2]; |
| 515 | row[k*3+0] = temp[0]; |
| 516 | row[k*3+1] = temp[1]; |
| 517 | row[k*3+2] = temp[2]; |
| 518 | } |
| 519 | } |
| 520 | } |
| 521 | |
| 522 | gluBuild2DMipmaps(target, GL_RGB, w, h, format, GL_UNSIGNED_BYTE, img); |
| 523 | free(img); |
| 524 | } |
| 525 | |
| 526 | |
| 527 | static void load_envmaps(void) |
| 528 | { |
| 529 | load(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, "right.rgb", GL_TRUE, GL_FALSE); |
| 530 | load(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, "left.rgb", GL_TRUE, GL_FALSE); |
| 531 | load(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, "top.rgb", GL_FALSE, GL_TRUE); |
| 532 | load(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, "bottom.rgb", GL_FALSE, GL_TRUE); |
| 533 | load(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, "front.rgb", GL_TRUE, GL_FALSE); |
| 534 | load(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, "back.rgb", GL_TRUE, GL_FALSE); |
| 535 | } |
| 536 | |
| 537 | |
| 538 | static void init( GLboolean useImageFiles ) |
| 539 | { |
Brian Paul | 6aa6ae8 | 2009-03-12 09:31:59 -0600 | [diff] [blame] | 540 | /* check for extensions */ |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 541 | if (!GLEW_ARB_texture_cube_map) { |
| 542 | printf("Sorry, this demo requires GL_ARB_texture_cube_map\n"); |
| 543 | exit(0); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 544 | } |
Ian Romanick | 8b0b335 | 2009-08-14 16:26:59 -0700 | [diff] [blame] | 545 | |
| 546 | /* Needed for glGenerateMipmapEXT / auto mipmapping |
| 547 | */ |
| 548 | supportFBO = GLEW_EXT_framebuffer_object; |
| 549 | |
| 550 | if (!supportFBO && !GLEW_SGIS_generate_mipmap) { |
| 551 | printf("Sorry, this demo requires GL_EXT_framebuffer_object or " |
| 552 | "GL_SGIS_generate_mipmap\n"); |
| 553 | exit(0); |
| 554 | } |
| 555 | |
| 556 | /* GLEW doesn't know about this extension yet, so use the old GLUT function |
| 557 | * to check for availability. |
| 558 | */ |
| 559 | supportSeamless = glutExtensionSupported("GL_ARB_seamless_cube_map"); |
| 560 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 561 | printf("GL_RENDERER: %s\n", (char *) glGetString(GL_RENDERER)); |
| 562 | |
Brian Paul | 0b0fc40 | 2009-09-15 17:13:49 -0600 | [diff] [blame] | 563 | |
| 564 | glGenTextures(1, &TexObj); |
| 565 | glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, TexObj); |
| 566 | |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 567 | if (useImageFiles) { |
| 568 | load_envmaps(); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 569 | } |
| 570 | else { |
| 571 | init_checkers(); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 572 | } |
| 573 | |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 574 | glEnable(GL_TEXTURE_CUBE_MAP_ARB); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 575 | glEnable(GL_DEPTH_TEST); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 576 | |
| 577 | glClearColor(.3, .3, .3, 0); |
| 578 | glColor3f( 1.0, 1.0, 1.0 ); |
| 579 | |
| 580 | set_mode(0); |
| 581 | } |
| 582 | |
| 583 | |
| 584 | static void usage(void) |
| 585 | { |
| 586 | printf("keys:\n"); |
| 587 | printf(" SPACE - toggle animation\n"); |
| 588 | printf(" CURSOR KEYS - rotation\n"); |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 589 | printf(" c - toggle texture clamp/wrap mode\n"); |
| 590 | printf(" f - toggle texture filter mode\n"); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 591 | printf(" m - toggle texgen reflection mode\n"); |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 592 | printf(" z/Z - change viewing distance\n"); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 593 | } |
| 594 | |
| 595 | |
Brian | 3a484cd | 2007-08-27 12:00:19 -0600 | [diff] [blame] | 596 | static void parse_args(int argc, char *argv[]) |
| 597 | { |
| 598 | int initFlag = 0; |
| 599 | int i; |
| 600 | |
| 601 | for (i = 1; i < argc; i++) { |
| 602 | if (strcmp(argv[i], "-i") == 0) |
| 603 | initFlag = 1; |
| 604 | else if (strcmp(argv[i], "--noclear") == 0) |
| 605 | NoClear = GL_TRUE; |
| 606 | else { |
| 607 | fprintf(stderr, "Bad option: %s\n", argv[i]); |
| 608 | exit(1); |
| 609 | } |
| 610 | } |
| 611 | init (initFlag); |
| 612 | } |
| 613 | |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 614 | int main( int argc, char *argv[] ) |
| 615 | { |
Brian Paul | a4f0b68 | 2002-10-25 17:20:26 +0000 | [diff] [blame] | 616 | glutInitWindowSize(600, 500); |
Brian Paul | 263f432 | 2009-12-18 08:12:55 -0700 | [diff] [blame] | 617 | glutInit(&argc, argv); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 618 | glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ); |
Brian Paul | 0b77a1c | 2003-04-09 21:50:08 +0000 | [diff] [blame] | 619 | glutCreateWindow("Texture Cube Mapping"); |
Brian Paul | 0e28e1a | 2009-03-09 11:49:46 -0600 | [diff] [blame] | 620 | glewInit(); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 621 | glutReshapeFunc( reshape ); |
| 622 | glutKeyboardFunc( key ); |
| 623 | glutSpecialFunc( specialkey ); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 624 | glutDisplayFunc( draw ); |
Brian Paul | 52a5cc0 | 2004-08-10 15:39:00 +0000 | [diff] [blame] | 625 | if (anim) |
| 626 | glutIdleFunc(idle); |
Brian | 3a484cd | 2007-08-27 12:00:19 -0600 | [diff] [blame] | 627 | parse_args(argc, argv); |
Brian Paul | d04d209 | 2000-05-30 01:18:29 +0000 | [diff] [blame] | 628 | usage(); |
| 629 | glutMainLoop(); |
| 630 | return 0; |
| 631 | } |