Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 1 | |
| 2 | /* Copyright (c) Mark J. Kilgard, 1997. */ |
| 3 | |
| 4 | /* This program is freely distributable without licensing fees |
| 5 | and is provided without guarantee or warrantee expressed or |
| 6 | implied. This program is -not- in the public domain. */ |
| 7 | |
| 8 | /* This example demonstrates how to render particle effects |
| 9 | with OpenGL. A cloud of pinkish/orange particles explodes with the |
| 10 | particles bouncing off the ground. When the EXT_point_parameters |
| 11 | is present , the particle size is attenuated based on eye distance. */ |
| 12 | |
| 13 | |
| 14 | /* Modified by Brian Paul to test GL_ARB_point_sprite */ |
| 15 | |
| 16 | |
| 17 | #include <stdio.h> |
| 18 | #include <stdlib.h> |
| 19 | #include <string.h> |
| 20 | #include <math.h> /* for cos(), sin(), and sqrt() */ |
| 21 | #ifdef _WIN32 |
| 22 | #include <windows.h> |
| 23 | #endif |
José Fonseca | 2e61d13 | 2009-01-24 16:39:49 +0000 | [diff] [blame] | 24 | #include <GL/glew.h> |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 25 | #include <GL/glut.h> |
| 26 | |
| 27 | /* Some <math.h> files do not define M_PI... */ |
| 28 | #ifndef M_PI |
| 29 | #define M_PI 3.14159265 |
| 30 | #endif |
| 31 | |
| 32 | #if 0 /* For debugging. */ |
| 33 | #undef GL_EXT_point_parameters |
| 34 | #endif |
| 35 | |
| 36 | static GLfloat angle = -150; /* in degrees */ |
| 37 | static int spin = 0; |
| 38 | static int moving, begin; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 39 | static float theTime; |
| 40 | static int repeat = 1; |
| 41 | static int blend = 1; |
| 42 | int useMipmaps = 1; |
| 43 | int linearFiltering = 1; |
| 44 | |
| 45 | static GLfloat constant[3] = { .2, 0.0, 0.0 }; |
| 46 | static GLfloat linear[3] = { .0, .1, 0.0 }; |
| 47 | static GLfloat theQuad[3] = { .005, 0.1, 1/600.0 }; |
| 48 | |
| 49 | #define MAX_POINTS 2000 |
| 50 | |
| 51 | static int numPoints = 200; |
| 52 | |
| 53 | static GLfloat pointList[MAX_POINTS][3]; |
| 54 | static GLfloat pointTime[MAX_POINTS]; |
| 55 | static GLfloat pointVelocity[MAX_POINTS][2]; |
| 56 | static GLfloat pointDirection[MAX_POINTS][2]; |
| 57 | static int colorList[MAX_POINTS]; |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 58 | static int animate = 1, motion = 0, org = 0, sprite = 1, smooth = 1; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 59 | |
| 60 | static GLfloat colorSet[][4] = { |
| 61 | /* Shades of red. */ |
| 62 | { 0.7, 0.2, 0.4, 0.5 }, |
| 63 | { 0.8, 0.0, 0.7, 0.5 }, |
| 64 | { 1.0, 0.0, 0.0, 0.5 }, |
| 65 | { 0.9, 0.3, 0.6, 0.5 }, |
| 66 | { 1.0, 0.4, 0.0, 0.5 }, |
| 67 | { 1.0, 0.0, 0.5, 0.5 }, |
| 68 | }; |
| 69 | |
| 70 | #define NUM_COLORS (sizeof(colorSet)/sizeof(colorSet[0])) |
| 71 | |
| 72 | #define DEAD (NUM_COLORS+1) |
| 73 | |
| 74 | |
| 75 | /* GL */ |
| 76 | static GLint spritePattern[16][16] = { |
| 77 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| 78 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| 79 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| 80 | { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 81 | { 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 82 | { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 83 | { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 84 | { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 85 | { 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0 }, |
| 86 | { 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0 }, |
| 87 | { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0 }, |
| 88 | { 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, |
| 89 | { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, |
| 90 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| 91 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| 92 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } |
| 93 | }; |
| 94 | |
| 95 | |
| 96 | |
| 97 | |
| 98 | #if 0 /* drand48 might be better on Unix machines */ |
| 99 | #define RANDOM_RANGE(lo, hi) ((lo) + (hi - lo) * drand48()) |
| 100 | #else |
| 101 | static float float_rand(void) { return rand() / (float) RAND_MAX; } |
| 102 | #define RANDOM_RANGE(lo, hi) ((lo) + (hi - lo) * float_rand()) |
| 103 | #endif |
| 104 | |
| 105 | #define MEAN_VELOCITY 3.0 |
| 106 | #define GRAVITY 2.0 |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 107 | |
| 108 | /* Modeling units of ground extent in each X and Z direction. */ |
| 109 | #define EDGE 12 |
| 110 | |
| 111 | static void |
| 112 | makePointList(void) |
| 113 | { |
| 114 | float angle, velocity, direction; |
| 115 | int i; |
| 116 | |
| 117 | motion = 1; |
| 118 | for (i=0; i<numPoints; i++) { |
| 119 | pointList[i][0] = 0.0; |
| 120 | pointList[i][1] = 0.0; |
| 121 | pointList[i][2] = 0.0; |
| 122 | pointTime[i] = 0.0; |
| 123 | angle = (RANDOM_RANGE(60.0, 70.0)) * M_PI/180.0; |
| 124 | direction = RANDOM_RANGE(0.0, 360.0) * M_PI/180.0; |
| 125 | pointDirection[i][0] = cos(direction); |
| 126 | pointDirection[i][1] = sin(direction); |
| 127 | velocity = MEAN_VELOCITY + RANDOM_RANGE(-0.8, 1.0); |
| 128 | pointVelocity[i][0] = velocity * cos(angle); |
| 129 | pointVelocity[i][1] = velocity * sin(angle); |
| 130 | colorList[i] = rand() % NUM_COLORS; |
| 131 | } |
| 132 | theTime = 0.0; |
| 133 | } |
| 134 | |
| 135 | static void |
| 136 | updatePointList(void) |
| 137 | { |
| 138 | float distance; |
| 139 | int i; |
| 140 | |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 141 | static double t0 = -1.; |
| 142 | double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0; |
| 143 | if (t0 < 0.0) |
| 144 | t0 = t; |
| 145 | dt = t - t0; |
| 146 | t0 = t; |
| 147 | |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 148 | motion = 0; |
| 149 | for (i=0; i<numPoints; i++) { |
| 150 | distance = pointVelocity[i][0] * theTime; |
| 151 | |
| 152 | /* X and Z */ |
| 153 | pointList[i][0] = pointDirection[i][0] * distance; |
| 154 | pointList[i][2] = pointDirection[i][1] * distance; |
| 155 | |
| 156 | /* Z */ |
| 157 | pointList[i][1] = |
| 158 | (pointVelocity[i][1] - 0.5 * GRAVITY * pointTime[i])*pointTime[i]; |
| 159 | |
| 160 | /* If we hit the ground, bounce the point upward again. */ |
| 161 | if (pointList[i][1] <= 0.0) { |
| 162 | if (distance > EDGE) { |
| 163 | /* Particle has hit ground past the distance duration of |
| 164 | the particles. Mark particle as dead. */ |
| 165 | colorList[i] = NUM_COLORS; /* Not moving. */ |
| 166 | continue; |
| 167 | } |
| 168 | |
| 169 | pointVelocity[i][1] *= 0.8; /* 80% of previous up velocity. */ |
| 170 | pointTime[i] = 0.0; /* Reset the particles sense of up time. */ |
| 171 | } |
| 172 | motion = 1; |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 173 | pointTime[i] += dt; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 174 | } |
Brian Paul | 92eddb0 | 2005-01-09 17:37:50 +0000 | [diff] [blame] | 175 | theTime += dt; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 176 | if (!motion && !spin) { |
| 177 | if (repeat) { |
| 178 | makePointList(); |
| 179 | } else { |
| 180 | glutIdleFunc(NULL); |
| 181 | } |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | static void |
| 186 | idle(void) |
| 187 | { |
| 188 | updatePointList(); |
| 189 | if (spin) { |
| 190 | angle += 0.3; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 191 | } |
| 192 | glutPostRedisplay(); |
| 193 | } |
| 194 | |
| 195 | static void |
| 196 | visible(int vis) |
| 197 | { |
| 198 | if (vis == GLUT_VISIBLE) { |
| 199 | if (animate && (motion || spin)) { |
| 200 | glutIdleFunc(idle); |
| 201 | } |
| 202 | } else { |
| 203 | glutIdleFunc(NULL); |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | static void |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 208 | redraw(void) |
| 209 | { |
| 210 | int i; |
| 211 | |
Ian Romanick | f359165 | 2009-06-30 17:29:14 -0700 | [diff] [blame] | 212 | glDepthMask(GL_TRUE); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 213 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 214 | |
| 215 | glPushMatrix(); |
| 216 | glRotatef(15.0, 1.0, 0.0, 0.0); |
| 217 | glRotatef(angle, 0.0, 1.0, 0.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 218 | |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 219 | |
| 220 | /* Draw the floor. */ |
| 221 | /* glEnable(GL_TEXTURE_2D);*/ |
| 222 | glColor3f(0.1, 0.5, 1.0); |
| 223 | glBegin(GL_QUADS); |
| 224 | glTexCoord2f(0.0, 0.0); |
| 225 | glVertex3f(-EDGE, -0.05, -EDGE); |
| 226 | glTexCoord2f(20.0, 0.0); |
| 227 | glVertex3f(EDGE, -0.05, -EDGE); |
| 228 | glTexCoord2f(20.0, 20.0); |
| 229 | glVertex3f(EDGE, -0.05, EDGE); |
| 230 | glTexCoord2f(0.0, 20.0); |
| 231 | glVertex3f(-EDGE, -0.05, EDGE); |
| 232 | glEnd(); |
| 233 | |
| 234 | /* Allow particles to blend with each other. */ |
Ian Romanick | f359165 | 2009-06-30 17:29:14 -0700 | [diff] [blame] | 235 | glDepthMask(GL_FALSE); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 236 | |
| 237 | if (blend) |
| 238 | glEnable(GL_BLEND); |
| 239 | |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 240 | if (sprite) { |
| 241 | glEnable(GL_TEXTURE_2D); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 242 | #ifdef GL_ARB_point_sprite |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 243 | glEnable(GL_POINT_SPRITE_ARB); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 244 | #endif |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 245 | } |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 246 | |
| 247 | glColor3f(1,1,1); |
| 248 | glBegin(GL_POINTS); |
| 249 | for (i=0; i<numPoints; i++) { |
| 250 | /* Draw alive particles. */ |
| 251 | if (colorList[i] != DEAD) { |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 252 | if (!sprite) glColor4fv(colorSet[colorList[i]]); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 253 | glVertex3fv(pointList[i]); |
| 254 | } |
| 255 | } |
| 256 | glEnd(); |
| 257 | |
| 258 | glDisable(GL_TEXTURE_2D); |
| 259 | #ifdef GL_ARB_point_sprite |
| 260 | glDisable(GL_POINT_SPRITE_ARB); |
| 261 | #endif |
| 262 | glDisable(GL_BLEND); |
| 263 | |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 264 | glPopMatrix(); |
| 265 | |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 266 | glutSwapBuffers(); |
| 267 | } |
| 268 | |
| 269 | /* ARGSUSED2 */ |
| 270 | static void |
| 271 | mouse(int button, int state, int x, int y) |
| 272 | { |
| 273 | /* Scene can be spun around Y axis using left |
| 274 | mouse button movement. */ |
| 275 | if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) { |
| 276 | moving = 1; |
| 277 | begin = x; |
| 278 | } |
| 279 | if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) { |
| 280 | moving = 0; |
| 281 | } |
| 282 | } |
| 283 | |
| 284 | /* ARGSUSED1 */ |
| 285 | static void |
| 286 | mouseMotion(int x, int y) |
| 287 | { |
| 288 | if (moving) { |
| 289 | angle = angle + (x - begin); |
| 290 | begin = x; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 291 | glutPostRedisplay(); |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | static void |
| 296 | menu(int option) |
| 297 | { |
| 298 | switch (option) { |
| 299 | case 0: |
| 300 | makePointList(); |
| 301 | break; |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 302 | #ifdef GL_ARB_point_parameters |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 303 | case 1: |
| 304 | glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, constant); |
| 305 | break; |
| 306 | case 2: |
| 307 | glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, linear); |
| 308 | break; |
| 309 | case 3: |
| 310 | glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad); |
| 311 | break; |
| 312 | #endif |
| 313 | case 4: |
| 314 | blend = 1; |
| 315 | break; |
| 316 | case 5: |
| 317 | blend = 0; |
| 318 | break; |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 319 | #ifdef GL_ARB_point_parameters |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 320 | case 6: |
| 321 | glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 1.0); |
| 322 | break; |
| 323 | case 7: |
| 324 | glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 10.0); |
| 325 | break; |
| 326 | #endif |
| 327 | case 8: |
| 328 | glEnable(GL_POINT_SMOOTH); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 329 | smooth = 1; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 330 | break; |
| 331 | case 9: |
| 332 | glDisable(GL_POINT_SMOOTH); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 333 | smooth = 0; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 334 | break; |
| 335 | case 10: |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 336 | glPointSize(16.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 337 | break; |
| 338 | case 11: |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 339 | glPointSize(32.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 340 | break; |
| 341 | case 12: |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 342 | glPointSize(64.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 343 | break; |
| 344 | case 13: |
| 345 | spin = 1 - spin; |
| 346 | if (animate && (spin || motion)) { |
| 347 | glutIdleFunc(idle); |
| 348 | } else { |
| 349 | glutIdleFunc(NULL); |
| 350 | } |
| 351 | break; |
| 352 | case 14: |
| 353 | numPoints = 200; |
| 354 | break; |
| 355 | case 15: |
| 356 | numPoints = 500; |
| 357 | break; |
| 358 | case 16: |
| 359 | numPoints = 1000; |
| 360 | break; |
| 361 | case 17: |
| 362 | numPoints = 2000; |
| 363 | break; |
| 364 | case 666: |
| 365 | exit(0); |
| 366 | } |
| 367 | glutPostRedisplay(); |
| 368 | } |
| 369 | |
| 370 | /* ARGSUSED1 */ |
| 371 | static void |
| 372 | key(unsigned char c, int x, int y) |
| 373 | { |
| 374 | switch (c) { |
| 375 | case 13: |
| 376 | animate = 1 - animate; /* toggle. */ |
| 377 | if (animate && (motion || spin)) { |
| 378 | glutIdleFunc(idle); |
| 379 | } else { |
| 380 | glutIdleFunc(NULL); |
| 381 | } |
| 382 | break; |
| 383 | case ' ': |
| 384 | animate = 1; |
| 385 | makePointList(); |
| 386 | glutIdleFunc(idle); |
| 387 | break; |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 388 | case 'o': |
| 389 | case 'O': |
| 390 | org ^= 1; |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 391 | #ifdef GL_VERSION_2_0 |
| 392 | #ifdef GL_ARB_point_parameters |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 393 | glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, |
| 394 | org ? GL_LOWER_LEFT : GL_UPPER_LEFT); |
| 395 | #endif |
| 396 | #endif |
| 397 | glutPostRedisplay(); |
| 398 | break; |
| 399 | case 't': |
| 400 | case 'T': |
| 401 | sprite ^= 1; |
| 402 | glutPostRedisplay(); |
| 403 | break; |
| 404 | case 's': |
| 405 | case 'S': |
| 406 | (smooth ^= 1) ? glEnable(GL_POINT_SMOOTH) : glDisable(GL_POINT_SMOOTH); |
| 407 | glutPostRedisplay(); |
| 408 | break; |
| 409 | case '0': |
| 410 | glPointSize(1.0); |
| 411 | glutPostRedisplay(); |
| 412 | break; |
| 413 | case '1': |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 414 | glPointSize(16.0); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 415 | glutPostRedisplay(); |
| 416 | break; |
| 417 | case '2': |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 418 | glPointSize(32.0); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 419 | glutPostRedisplay(); |
| 420 | break; |
| 421 | case '3': |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 422 | glPointSize(64.0); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 423 | glutPostRedisplay(); |
| 424 | break; |
| 425 | case '4': |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 426 | glPointSize(128.0); |
Daniel Borca | a9ea162 | 2004-09-13 08:47:01 +0000 | [diff] [blame] | 427 | glutPostRedisplay(); |
| 428 | break; |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 429 | case 27: |
| 430 | exit(0); |
| 431 | } |
| 432 | } |
| 433 | |
| 434 | |
| 435 | |
| 436 | static void |
| 437 | makeSprite(void) |
| 438 | { |
| 439 | GLubyte texture[16][16][4]; |
| 440 | int i, j; |
| 441 | |
| 442 | if (!glutExtensionSupported("GL_ARB_point_sprite")) { |
| 443 | printf("Sorry, this demo requires GL_ARB_point_sprite.\n"); |
| 444 | exit(0); |
| 445 | } |
| 446 | if (!glutExtensionSupported("GL_ARB_point_parameters")) { |
| 447 | printf("Sorry, this demo requires GL_ARB_point_parameters.\n"); |
| 448 | exit(0); |
| 449 | } |
| 450 | |
| 451 | for (i = 0; i < 16; i++) { |
| 452 | for (j = 0; j < 16; j++) { |
| 453 | if (spritePattern[i][j]) { |
| 454 | texture[i][j][0] = 255; |
| 455 | texture[i][j][1] = 255; |
| 456 | texture[i][j][2] = 255; |
| 457 | texture[i][j][3] = 255; |
| 458 | } |
| 459 | else { |
| 460 | texture[i][j][0] = 255; |
| 461 | texture[i][j][1] = 0; |
| 462 | texture[i][j][2] = 0; |
| 463 | texture[i][j][3] = 0; |
| 464 | } |
| 465 | } |
| 466 | } |
| 467 | |
| 468 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, |
| 469 | texture); |
| 470 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| 471 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| 472 | #ifdef GL_ARB_point_sprite |
| 473 | glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE); |
| 474 | #endif |
| 475 | } |
| 476 | |
| 477 | |
| 478 | static void |
| 479 | reshape(int width, int height) |
| 480 | { |
| 481 | GLfloat h = (GLfloat) height / (GLfloat) width; |
| 482 | |
| 483 | glViewport(0, 0, (GLint) width, (GLint) height); |
| 484 | glMatrixMode(GL_PROJECTION); |
| 485 | glLoadIdentity(); |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 486 | glFrustum(-1.0, 1.0, -h, h, 2.0, 30.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 487 | glMatrixMode(GL_MODELVIEW); |
| 488 | glLoadIdentity(); |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 489 | glTranslatef(0.0, 0.0, -10.0); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 490 | } |
| 491 | |
| 492 | int |
| 493 | main(int argc, char **argv) |
| 494 | { |
| 495 | int i; |
Brian Paul | 263f432 | 2009-12-18 08:12:55 -0700 | [diff] [blame] | 496 | |
| 497 | glutInitWindowSize(600,300); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 498 | glutInit(&argc, argv); |
| 499 | glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); |
| 500 | |
| 501 | for (i=1; i<argc; i++) { |
| 502 | if(!strcmp("-noms", argv[i])) { |
| 503 | glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); |
| 504 | printf("forcing no multisampling\n"); |
| 505 | } else if(!strcmp("-nomipmaps", argv[i])) { |
| 506 | useMipmaps = 0; |
| 507 | } else if(!strcmp("-nearest", argv[i])) { |
| 508 | linearFiltering = 0; |
| 509 | } |
| 510 | } |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 511 | glutCreateWindow("sprite blast"); |
José Fonseca | 2e61d13 | 2009-01-24 16:39:49 +0000 | [diff] [blame] | 512 | glewInit(); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 513 | glutReshapeFunc(reshape); |
| 514 | glutDisplayFunc(redraw); |
| 515 | glutMouseFunc(mouse); |
| 516 | glutMotionFunc(mouseMotion); |
| 517 | glutVisibilityFunc(visible); |
| 518 | glutKeyboardFunc(key); |
| 519 | glutCreateMenu(menu); |
| 520 | glutAddMenuEntry("Reset time", 0); |
| 521 | glutAddMenuEntry("Constant", 1); |
| 522 | glutAddMenuEntry("Linear", 2); |
| 523 | glutAddMenuEntry("Quadratic", 3); |
| 524 | glutAddMenuEntry("Blend on", 4); |
| 525 | glutAddMenuEntry("Blend off", 5); |
| 526 | glutAddMenuEntry("Threshold 1", 6); |
| 527 | glutAddMenuEntry("Threshold 10", 7); |
| 528 | glutAddMenuEntry("Point smooth on", 8); |
| 529 | glutAddMenuEntry("Point smooth off", 9); |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 530 | glutAddMenuEntry("Point size 16", 10); |
| 531 | glutAddMenuEntry("Point size 32", 11); |
| 532 | glutAddMenuEntry("Point size 64", 12); |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 533 | glutAddMenuEntry("Toggle spin", 13); |
| 534 | glutAddMenuEntry("200 points ", 14); |
| 535 | glutAddMenuEntry("500 points ", 15); |
| 536 | glutAddMenuEntry("1000 points ", 16); |
| 537 | glutAddMenuEntry("2000 points ", 17); |
| 538 | glutAddMenuEntry("Quit", 666); |
| 539 | glutAttachMenu(GLUT_RIGHT_BUTTON); |
| 540 | |
Roland Scheidegger | af1dc7e | 2006-08-28 21:19:34 +0000 | [diff] [blame] | 541 | makePointList(); |
| 542 | makeSprite(); |
| 543 | |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 544 | glShadeModel(GL_FLAT); |
| 545 | glEnable(GL_DEPTH_TEST); |
| 546 | glEnable(GL_POINT_SMOOTH); |
| 547 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
Brian | 3b10f50 | 2007-06-28 07:15:11 -0600 | [diff] [blame] | 548 | glPointSize(32.0); |
Brian Paul | 6fedd4e | 2004-09-16 19:32:49 +0000 | [diff] [blame] | 549 | #ifdef GL_ARB_point_parameters |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 550 | glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad); |
| 551 | #endif |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 552 | |
Brian Paul | 1a89978 | 2003-09-24 20:41:53 +0000 | [diff] [blame] | 553 | glutMainLoop(); |
| 554 | return 0; /* ANSI C requires main to return int. */ |
| 555 | } |