static void
updatePointList(void)
{
float distance;
int i;
static double t0 = -1.;
double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
if (t0 < 0.0)
t0 = t;
dt = t - t0;
t0 = t;
motion = 0;
for (i=0; i<numPoints; i++) {
distance = pointVelocity[i][0] * theTime;
/* X and Z */
pointList[i][0] = pointDirection[i][0] * distance;
pointList[i][2] = pointDirection[i][1] * distance;
/* Z */
pointList[i][1] =
(pointVelocity[i][1] - 0.5 * GRAVITY * pointTime[i])*pointTime[i];
/* If we hit the ground, bounce the point upward again. */
if (pointList[i][1] <= 0.0) {
if (distance > EDGE) {
/* Particle has hit ground past the distance duration of
the particles. Mark particle as dead. */
colorList[i] = NUM_COLORS; /* Not moving. */
continue;
}
pointVelocity[i][1] *= 0.8; /* 80% of previous up velocity. */
pointTime[i] = 0.0; /* Reset the particles sense of up time. */
}
motion = 1;
pointTime[i] += dt;
}
theTime += dt;
if (!motion && !spin) {
if (repeat) {
makePointList();
} else {
glutIdleFunc(NULL);
}
}
}
/* ARGSUSED1 */
void
key(unsigned char c, int x, int y)
{
switch (c) {
case 13:
animate = 1 - animate; /* toggle. */
if (animate && (motion || spin)) {
glutIdleFunc(idle);
} else {
glutIdleFunc(NULL);
}
break;
case ' ':
animate = 1;
makePointList();
glutIdleFunc(idle);
break;
case 27:
exit(0);
}
}
int
main(int argc, char **argv)
{
int i;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
for (i=1; i<argc; i++) {
if(!strcmp("-noms", argv[i])) {
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
printf("forcing no multisampling\n");
} else if(!strcmp("-nomipmaps", argv[i])) {
useMipmaps = 0;
} else if(!strcmp("-nearest", argv[i])) {
linearFiltering = 0;
}
}
glutCreateWindow("point burst");
glutDisplayFunc(redraw);
glutMouseFunc(mouse);
glutMotionFunc(mouseMotion);
glutVisibilityFunc(visible);
glutKeyboardFunc(key);
glutCreateMenu(menu);
glutAddMenuEntry("Reset time", 0);
glutAddMenuEntry("Constant", 1);
glutAddMenuEntry("Linear", 2);
glutAddMenuEntry("Quadratic", 3);
glutAddMenuEntry("Blend on", 4);
glutAddMenuEntry("Blend off", 5);
glutAddMenuEntry("Threshold 1", 6);
glutAddMenuEntry("Threshold 10", 7);
glutAddMenuEntry("Point smooth on", 8);
glutAddMenuEntry("Point smooth off", 9);
glutAddMenuEntry("Point size 2", 10);
glutAddMenuEntry("Point size 4", 11);
glutAddMenuEntry("Point size 8", 12);
glutAddMenuEntry("Toggle spin", 13);
glutAddMenuEntry("200 points ", 14);
glutAddMenuEntry("500 points ", 15);
glutAddMenuEntry("1000 points ", 16);
glutAddMenuEntry("2000 points ", 17);
glutAddMenuEntry("Quit", 666);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glEnable(GL_DEPTH_TEST);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPointSize(8.0);
#if GL_SGIS_point_parameters
glPointParameterfvSGIS(GL_DISTANCE_ATTENUATION_SGIS, quad);
#endif
glMatrixMode(GL_PROJECTION);
gluPerspective( /* field of view in degree */ 40.0,
/* aspect ratio */ 1.0,
/* Z near */ 0.5, /* Z far */ 40.0);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.0, 1.0, 8.0, /* eye location */
0.0, 1.0, 0.0, /* center is at (0,0,0) */
0.0, 1.0, 0.); /* up is in postivie Y direction */
glPushMatrix(); /* dummy push so we can pop on model
recalc */
makePointList();
makeFloorTexture();
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
void
menu(int option)
{
switch (option) {
case 0:
makePointList();
break;
#if GL_SGIS_point_parameters
case 1:
glPointParameterfvSGIS(GL_DISTANCE_ATTENUATION_SGIS, constant);
break;
case 2:
glPointParameterfvSGIS(GL_DISTANCE_ATTENUATION_SGIS, linear);
break;
case 3:
glPointParameterfvSGIS(GL_DISTANCE_ATTENUATION_SGIS, quad);
break;
#endif
case 4:
glEnable(GL_BLEND);
break;
case 5:
glDisable(GL_BLEND);
break;
#if GL_SGIS_point_parameters
case 6:
glPointParameterfSGIS(GL_POINT_FADE_THRESHOLD_SIZE_SGIS, 1.0);
break;
case 7:
glPointParameterfSGIS(GL_POINT_FADE_THRESHOLD_SIZE_SGIS, 10.0);
break;
#endif
case 8:
glEnable(GL_POINT_SMOOTH);
break;
case 9:
glDisable(GL_POINT_SMOOTH);
break;
case 10:
glPointSize(2.0);
break;
case 11:
glPointSize(4.0);
break;
case 12:
glPointSize(8.0);
break;
case 13:
spin = 1 - spin;
if (animate && (spin || motion)) {
glutIdleFunc(idle);
} else {
glutIdleFunc(NULL);
}
break;
case 14:
numPoints = 200;
break;
case 15:
numPoints = 500;
break;
case 16:
numPoints = 1000;
break;
case 17:
numPoints = 2000;
break;
case 666:
exit(0);
}
glutPostRedisplay();
}
int main (int argc, char **argv)
{
Options mergetr = readParameters (argc, argv);
char filename_mesh_node[FILENAME_MAX];
char filename_mesh_ele[FILENAME_MAX];
char filename_otoczka[FILENAME_MAX];
char filename_output_node[FILENAME_MAX];
char filename_output_ele[FILENAME_MAX];
int no_of_meshes = argc-mergetr.args_start;
strcpy (filename_otoczka, mergetr.input);
if ( strstr (filename_otoczka, ".poly") == NULL)
strcat (filename_otoczka, ".poly");
strcpy (filename_output_node, mergetr.output);
strcat (filename_output_node, ".node");
strcpy (filename_output_ele, mergetr.output);
strcat (filename_output_ele, ".ele");
fprintf(stdout, "************************************\n");
fprintf(stdout, "***** M * E * R * G * E * T * R ****\n");
fprintf(stdout, "************************************\n");
fprintf(stdout, "* Otoczka filename: %s\n", filename_otoczka);
fprintf(stdout, "* Output filenames: %s & %s\n", filename_output_node, filename_output_ele);
fprintf(stdout, "* Triangle options: %s\n", mergetr.tr_opt);
fprintf(stdout, "************************************\n");
struct triangulateio *siatka;
struct triangulateio otoczka;
struct triangulateio out;
EdgeList **v;
PointList **p;
int i;
siatka = malloc ( no_of_meshes * sizeof *siatka);
v = malloc ( no_of_meshes * sizeof **v );
p = malloc ( no_of_meshes * sizeof **p );
if (siatka == NULL || v == NULL || p == NULL) {
fprintf (stderr, "** Error! Not enough memory!");
return -1;
}
initTriangulation (&otoczka);
/* OTOCZKA */
FILE *file_otoczka = fopen( filename_otoczka, "r");
if (file_otoczka == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_otoczka);
return -100;
}
readPoints (file_otoczka, &otoczka);
readSegments (file_otoczka, &otoczka);
readHoles (file_otoczka, &otoczka);
readRegions (file_otoczka, &otoczka);
fclose (file_otoczka);
/* MESHES */
for (i = 0; i < (argc - mergetr.args_start); i++) {
strcpy (filename_mesh_node, argv[mergetr.args_start+i]);
strcat (filename_mesh_node, ".node");
strcpy (filename_mesh_ele, argv[mergetr.args_start+i]);
strcat (filename_mesh_ele, ".ele");
fprintf(stdout, "************************************\n");
fprintf(stdout, "* Mesh filenames: %s & %s\n", filename_mesh_node, filename_mesh_ele);
fprintf(stdout, "************************************\n");
FILE *file_mesh_node = fopen( filename_mesh_node, "r");
FILE *file_mesh_ele = fopen( filename_mesh_ele, "r");
if (file_mesh_node == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_mesh_node);
return -101;
}
if (file_mesh_node == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_mesh_ele);
return -102;
}
initTriangulation (&siatka[i]);
readPoints (file_mesh_node, &siatka[i]);
readTriangles (file_mesh_ele, &siatka[i]);
fclose (file_mesh_node);
fclose (file_mesh_ele);
v[i] = createEdgeList(siatka[i]);
markBndEdges (siatka[i], v[i]);
p[i] = makePointList (otoczka, siatka[i], v[i]);
updatePoints (&otoczka, siatka[i], v[i], p[i]);
updateSegments (&otoczka, siatka[i], v[i], p[i]);
updateHoles (&otoczka, siatka[i]);
}
fprintf(stdout, "************************************\n");
/* TRIANGULAtE */
initTriangulation (&out);
strcat (mergetr.tr_opt, "pYYQ");
triangulate (mergetr.tr_opt, &otoczka, &out, (struct triangulateio *) NULL);
/* GLUE HOLES */
/* markNotBndEdges (siatka1, v); */
for (i = 0; i < no_of_meshes; i++) {
glueNotBndPoints (&out, siatka[i], p[i]); /* DOKLEJANIE DO OUT */
fixPointListNumbers (&out, &siatka[i], p[i]);
glueInteriorTriangles (&out, siatka[i], p[i]);
removeHole (&out);
}
FILE *file_output_node = fopen (filename_output_node, "w");
FILE *file_output_ele = fopen (filename_output_ele, "w");
writePoints (file_output_node, out);
writeTriangles (file_output_ele, out);
fclose (file_output_node);
fclose (file_output_ele);
fprintf(stdout, "************************************\n");
free (p);
free (v);
freeTriangulation (&otoczka);
freeTriangulation (&out);
for (i = 0; i < no_of_meshes; i++)
freeTriangulation (&siatka[i]);
return 0;
}
int
main(int argc, char **argv)
{
int i;
glutInitWindowSize(600,300);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
for (i=1; i<argc; i++) {
if(!strcmp("-noms", argv[i])) {
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
printf("forcing no multisampling\n");
} else if(!strcmp("-nomipmaps", argv[i])) {
useMipmaps = 0;
} else if(!strcmp("-nearest", argv[i])) {
linearFiltering = 0;
}
}
glutCreateWindow("sprite blast");
glewInit();
glutReshapeFunc(reshape);
glutDisplayFunc(redraw);
glutMouseFunc(mouse);
glutMotionFunc(mouseMotion);
glutVisibilityFunc(visible);
glutKeyboardFunc(key);
glutCreateMenu(menu);
glutAddMenuEntry("Reset time", 0);
glutAddMenuEntry("Constant", 1);
glutAddMenuEntry("Linear", 2);
glutAddMenuEntry("Quadratic", 3);
glutAddMenuEntry("Blend on", 4);
glutAddMenuEntry("Blend off", 5);
glutAddMenuEntry("Threshold 1", 6);
glutAddMenuEntry("Threshold 10", 7);
glutAddMenuEntry("Point smooth on", 8);
glutAddMenuEntry("Point smooth off", 9);
glutAddMenuEntry("Point size 16", 10);
glutAddMenuEntry("Point size 32", 11);
glutAddMenuEntry("Point size 64", 12);
glutAddMenuEntry("Toggle spin", 13);
glutAddMenuEntry("200 points ", 14);
glutAddMenuEntry("500 points ", 15);
glutAddMenuEntry("1000 points ", 16);
glutAddMenuEntry("2000 points ", 17);
glutAddMenuEntry("Quit", 666);
glutAttachMenu(GLUT_RIGHT_BUTTON);
makePointList();
makeSpriteTextures();
makeFragShader();
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_POINT_SMOOTH);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPointSize(32.0);
#ifdef GL_ARB_point_parameters
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad);
#endif
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
/* ARGSUSED1 */
static void
key(unsigned char c, int x, int y)
{
switch (c) {
case 13:
animate = 1 - animate; /* toggle. */
if (animate && (motion || spin)) {
glutIdleFunc(idle);
} else {
glutIdleFunc(NULL);
}
break;
case ' ':
animate = 1;
makePointList();
glutIdleFunc(idle);
break;
case 'o':
case 'O':
org ^= 1;
#ifdef GL_VERSION_2_0
#ifdef GL_ARB_point_parameters
glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN,
org ? GL_LOWER_LEFT : GL_UPPER_LEFT);
#endif
#endif
glutPostRedisplay();
break;
case 't':
case 'T':
sprite ^= 1;
glutPostRedisplay();
break;
case 's':
case 'S':
(smooth ^= 1) ? glEnable(GL_POINT_SMOOTH) : glDisable(GL_POINT_SMOOTH);
glutPostRedisplay();
break;
case 'f':
case 'F':
if (HaveShaders) {
UseFragShader = !UseFragShader;
glutPostRedisplay();
}
break;
case '0':
glPointSize(1.0);
glutPostRedisplay();
break;
case '1':
glPointSize(16.0);
glutPostRedisplay();
break;
case '2':
glPointSize(32.0);
glutPostRedisplay();
break;
case '3':
glPointSize(64.0);
glutPostRedisplay();
break;
case '4':
glPointSize(128.0);
glutPostRedisplay();
break;
case 27:
exit(0);
}
}
static void
menu(int option)
{
switch (option) {
case 0:
makePointList();
break;
#ifdef GL_ARB_point_parameters
case 1:
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, constant);
break;
case 2:
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, linear);
break;
case 3:
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad);
break;
#endif
case 4:
blend = 1;
break;
case 5:
blend = 0;
break;
#ifdef GL_ARB_point_parameters
case 6:
glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 1.0);
break;
case 7:
glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 10.0);
break;
#endif
case 8:
glEnable(GL_POINT_SMOOTH);
smooth = 1;
break;
case 9:
glDisable(GL_POINT_SMOOTH);
smooth = 0;
break;
case 10:
glPointSize(16.0);
break;
case 11:
glPointSize(32.0);
break;
case 12:
glPointSize(64.0);
break;
case 13:
spin = 1 - spin;
if (animate && (spin || motion)) {
glutIdleFunc(idle);
} else {
glutIdleFunc(NULL);
}
break;
case 14:
numPoints = 200;
break;
case 15:
numPoints = 500;
break;
case 16:
numPoints = 1000;
break;
case 17:
numPoints = 2000;
break;
case 666:
exit(0);
}
glutPostRedisplay();
}