static void Draw(void)
{
static GLfloat theQuad[3] = { 0.25, 0.0, 1/60.0 };
glClear(GL_COLOR_BUFFER_BIT);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPointSize(8.0);
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, theQuad);
glBegin(GL_POINTS);
glColor3f(1,0,0);
glVertex3f( 0.9, -0.9, -10.0);
glColor3f(1,1,0);
glVertex3f( 0.9, 0.9, -5.0);
glColor3f(1,0,1);
glVertex3f(-0.9, 0.9, -30.0);
glColor3f(0,1,1);
glVertex3f(-0.9, -0.9, -20.0);
glEnd();
glFlush();
if (doubleBuffer) {
glutSwapBuffers();
}
}
void __glXDisp_PointParameterfvARB(GLbyte *pc)
{
glPointParameterfvARB(
*(GLenum *)(pc + 0),
(GLfloat *)(pc + 4)
);
}
inline void VL_glPointParameterfv( GLenum pname, const GLfloat* params)
{
if (glPointParameterfv)
glPointParameterfv(pname,(GLfloat*)params);
else
if (glPointParameterfvARB)
glPointParameterfvARB(pname,(GLfloat*)params);
else
if (glPointParameterfvEXT)
glPointParameterfvEXT(pname,(GLfloat*)params);
else
VL_UNSUPPORTED_FUNC();
}
void SimpleSparkle::draw() {
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glColor3f(1.0, 1.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE );
// This is how will our point sprite's size will be modified by
// distance from the viewer
float quadratic[] = { 1.0f, 0.0f, 0.01f };
glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic );
// Query for the max point size supported by the hardware
float maxSize = 0.0f;
glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize );
// Clamp size to 100.0f or the sprites could get a little too big on some
// of the newer graphic cards. My ATI card at home supports a max point
// size of 1024.0f!
if( maxSize > 100.0f )
maxSize = 100.0f;
glPointSize( pointSize );
// The alpha of a point is calculated to allow the fading of points
// instead of shrinking them past a defined threshold size. The threshold
// is defined by GL_POINT_FADE_THRESHOLD_SIZE_ARB and is not clamped to
// the minimum and maximum point sizes.
//glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f );
glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, maxSize );
// Specify point sprite texture coordinate replacement mode for each
// texture unit
glTexEnvf( 0x8861, 0x8862, GL_TRUE );
glEnable( 0x8861 );
glDrawArrays(GL_POINTS, 0, count);
// glBegin(GL_POINTS);
// glVertex2f(vertexArray[1], 0.0);
// glEnd();
glDisable( 0x8861 );
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
}
void PointParticle::render(){
//TODO alguams dessas funcoes sao de inicializacao do opengl
//e devem ficar em outro local
float quadratic[] = { 1.0f, 0.0f, 0.01f };
glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic );
glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f );
glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f );
glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
glEnable( GL_POINT_SPRITE_ARB );
glPointSize( size );
glBegin( GL_POINTS );
glColor4f( color[0], color[1], color[2], 1 - fade / life);
glVertex3f( position[0], position[1], position[2] );
glEnd();
glDisable( GL_POINT_SPRITE_ARB );
};
void GLStateCacheManagerImp::setPointParameters(GLfloat *attenuation, float minSize, float maxSize)
{
if (minSize != mPointSizeMin)
{
mPointSizeMin = minSize;
const Ogre::RenderSystemCapabilities* caps = dynamic_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem())->getCapabilities();
if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS))
glPointParameterf(GL_POINT_SIZE_MIN, mPointSizeMin);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_ARB))
glPointParameterfARB(GL_POINT_SIZE_MIN, mPointSizeMin);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_EXT))
glPointParameterfEXT(GL_POINT_SIZE_MIN, mPointSizeMin);
}
if (maxSize != mPointSizeMax)
{
mPointSizeMax = maxSize;
const Ogre::RenderSystemCapabilities* caps = dynamic_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem())->getCapabilities();
if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS))
glPointParameterf(GL_POINT_SIZE_MAX, mPointSizeMax);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_ARB))
glPointParameterfARB(GL_POINT_SIZE_MAX, mPointSizeMax);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_EXT))
glPointParameterfEXT(GL_POINT_SIZE_MAX, mPointSizeMax);
}
if (attenuation[0] != mPointAttenuation[0] || attenuation[1] != mPointAttenuation[1] || attenuation[2] != mPointAttenuation[2])
{
mPointAttenuation[0] = attenuation[0];
mPointAttenuation[1] = attenuation[1];
mPointAttenuation[2] = attenuation[2];
const Ogre::RenderSystemCapabilities* caps = dynamic_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem())->getCapabilities();
if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS))
glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, &mPointAttenuation[0]);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_ARB))
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION, &mPointAttenuation[0]);
else if (caps->hasCapability(RSC_POINT_EXTENDED_PARAMETERS_EXT))
glPointParameterfvEXT(GL_POINT_DISTANCE_ATTENUATION, &mPointAttenuation[0]);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBPointParameters_nglPointParameterfvARB__IJ(JNIEnv *__env, jclass clazz, jint pname, jlong paramsAddress) {
glPointParameterfvARBPROC glPointParameterfvARB = (glPointParameterfvARBPROC)tlsGetFunction(1257);
intptr_t params = (intptr_t)paramsAddress;
UNUSED_PARAM(clazz)
glPointParameterfvARB(pname, params);
}
CatchSparksEffect::CatchSparksEffect(EffectSettings *conf)
: Effect()
{
flowerCount = conf->getIntegerOrDefault("flowercount", 30);
blossomCount = conf->getIntegerOrDefault("blossomcount", 3);
sparkCount = conf->getIntegerOrDefault("sparkcount", 30);
blossomsize = conf->getFloatOrDefault("blossomsize", 12.0);
sparksize = conf->getFloatOrDefault("sparksize", 10.0);
xd = 4.0 / env->getMatrixWidth();
yd = 2.0 / env->getMatrixHeight();
Flower::setSparkCount(sparkCount);
Flower::setBlossomCount(blossomCount);
Flower::setAreaDetector(&detector);
Flower::setxyd(xd, yd);
flowers = new Flower[flowerCount];
int verticesTotal = flowerCount * (blossomCount + sparkCount);
vertices = new GLfloat[2 * verticesTotal];
colors = new GLfloat[4 * verticesTotal];
for ( int i = 0; i < verticesTotal; ++i) {
vertices[2*i] = 0.0;
vertices[2*i+1] = 0.0;
colors[4*i] = 1.0;
colors[4*i+1] = 1.0;
colors[4*i+2] = 1.0;
colors[4*i+3] = 1.0;
}
unsigned int sparkoffset = blossomCount * 2 * flowerCount; // sparks are stored behind blossoms
for (unsigned int i = 0; i < flowerCount; ++i) {
flowers[i].setBlossomPointers(vertices + i * 2 * blossomCount, colors + i * 4 * blossomCount);
flowers[i].setSparksPointers(vertices + sparkoffset + i * 2 * sparkCount, colors + 2*sparkoffset + i * 4 * sparkCount);
flowers[i].reset();
}
RGBAbmp *pic = loadBmp("data/blossom.bmp");
glGenTextures(1, &blossomTex);
glBindTexture(GL_TEXTURE_2D, blossomTex);
int textureType = GL_RGB;
if (pic->bpp == 32)
textureType = GL_RGBA ;
gluBuild2DMipmaps(GL_TEXTURE_2D, pic->bpp/8, pic->width,
pic->height, textureType, GL_UNSIGNED_BYTE, pic->data);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);
delete pic->data;
delete pic;
pic = loadBmp("data/whiteflare.bmp");
glGenTextures(1, &sparkTex);
glBindTexture(GL_TEXTURE_2D, sparkTex);
if (pic->bpp == 32)
textureType = GL_RGBA ;
gluBuild2DMipmaps(GL_TEXTURE_2D, pic->bpp/8, pic->width,
pic->height, textureType, GL_UNSIGNED_BYTE, pic->data);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);
delete pic->data;
delete pic;
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT,0, vertices);
glColorPointer(4, GL_FLOAT,0, colors);
glColor3f(1.0, 1.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_DST_ALPHA );
// This is how will our point sprite's size will be modified by
// distance from the viewer
float quadratic[] = { 1.0f, 0.0f, 0.01f };
glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic );
glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f );
glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f );
// Specify point sprite texture coordinate replacement mode for each
// texture unit
glTexEnvf( 0x8861, 0x8862, GL_TRUE );
glEnable( 0x8861 );
}
void ParticleSprayerTool::render(DTS::DataItem* dataItem) const
{
// draw all emitter objects
drawEmitters();
// save current attribute state
#ifdef MESA
// GL_POINT_BIT causes GL enum error
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
#else
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT);
#endif
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, dataItem->spriteTextureObjectId);
glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
glEnable(GL_POINT_SPRITE_ARB);
float particleRadius=data.point_radius;//*1000.0;
// Query the OpenGL viewing frustrum
GLFrustum<float> frustum;
frustum.setFromGL();
#ifdef GHETTO
if (0)
#else
if (dataItem->hasShaders)
#endif
{
/* Calculate the scaled point size for this frustum: */
GLfloat scaledParticleRadius=frustum.getPixelSize() * particleRadius / frustum.getEyeScreenDistance();
/* Enable the vertex/fragment shader: */
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
glUseProgramObjectARB(dataItem->programObject);
glUniform1fARB(dataItem->scaledParticleRadiusLocation, scaledParticleRadius);
glUniform1iARB(dataItem->tex0Location, 0);
}
else
{
glPointSize(particleRadius
* Vrui::getNavigationTransformation().getScaling());
GLfloat linear[3]= { 0.0, 1 / 5.0, 0.0 };
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, linear);
//
// NOTE::the following scaling calculation does not work properly
// in the CAVE. This is due to changes in the OpenGL library and
// cannot be fixed. On a 2D screen the scaling should look correct.
//
// Calculate the nominal pixel size for particles
float pointSizeCounter=frustum.getPixelSize() * 2.0f * particleRadius;
float pointSizeDenominator=frustum.getEyeScreenDistance();
// Query the maximum point size accepted by glPointSize(...)
GLfloat pointSizeRange[2];
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, pointSizeRange);
// Enable point parameters
glPointSize(pointSizeRange[1]); // select the maximum point size
pointSizeCounter/=pointSizeRange[1]; // adjust the point size numerator
GLfloat attenuation[3]= { 0.0f, 0.0f, 0.0f };
attenuation[2]=Math::sqr(pointSizeDenominator / pointSizeCounter);
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, attenuation);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, dataItem->vertexBufferId);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
if (dataItem->versionDS != data.currentVersion)
{
dataItem->numParticlesDS = data.particles.size();
glBufferDataARB(GL_ARRAY_BUFFER_ARB, dataItem->numParticlesDS * sizeof(PointParticle), &data.particles[0], GL_DYNAMIC_DRAW_ARB);
dataItem->versionDS = data.currentVersion;
}
glInterleavedArrays(GL_C4UB_V3F, sizeof(PointParticle), 0);
// Care needed if particle number has changed but we haven't updated buffer.
glDrawArrays(GL_POINTS, 0, dataItem->numParticlesDS);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
#ifndef GHETTO
if (dataItem->hasShaders)
#endif
{
glUseProgramObjectARB(0);
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
}
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_POINT_SPRITE_ARB);
// restore previous attribute state
glPopAttrib();
}
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. */
}
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();
}
void DotSpreaderTool::render(DTS::DataItem* dataItem) const
{
// if dragging locator render release sphere
if (active and !data.running)
{
// save current attribute state
#ifdef MESA
// GL_POINT_BIT causes GL enum error
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
#else
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT);
#endif
glDisable(GL_LIGHTING);
// save current location
glPushMatrix();
// move to center of sphere
glTranslatef(org[0], org[1], org[2]);
// compute radius of sphere
float radius=Math::sqrt((pos[0] - org[0]) * (pos[0] - org[0]) + (pos[1]
- org[1]) * (pos[1] - org[1]) + (pos[2] - org[2]) * (pos[2]
- org[2]));
GLUquadricObj *quadric=gluNewQuadric();
// draw transparent sphere
gluQuadricDrawStyle(quadric, GLU_FILL);
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.0f, 0.6f, 1.0f, 0.2f);
gluSphere(quadric, radius, 10, 15);
glDisable(GL_BLEND);
// draw surrounding wireframe (solid)
gluQuadricDrawStyle(quadric, GLU_LINE);
glDepthMask(GL_TRUE);
glColor4f(0.0f, 0.8f, 1.0f, 1.0f);
gluSphere(quadric, radius, 10, 15);
glDepthMask(GL_FALSE);
gluDeleteQuadric(quadric);
// restore previous position
glPopMatrix();
// restore previous attribute state
glPopAttrib();
}
// if simulation is running draw particles
else if (data.running)
{
// save current attribute state
#ifdef MESA
// GL_POINT_BIT causes GL enum error
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
#else
glPushAttrib(GL_LIGHTING_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_POINT_BIT);
#endif
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, dataItem->spriteTextureObjectId);
glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
glEnable(GL_POINT_SPRITE_ARB);
float particleRadius=data.point_radius;
// Query the OpenGL viewing frustum
GLFrustum<float> frustum;
frustum.setFromGL();
#ifdef GHETTO
if (0)
#else
if (dataItem->hasShaders)
#endif
{
/* Calculate the scaled point size for this frustum: */
GLfloat scaledParticleRadius=frustum.getPixelSize() * particleRadius
/ frustum.getEyeScreenDistance();
/* Enable the vertex/fragment shader: */
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
glUseProgramObjectARB(dataItem->programObject);
glUniform1fARB(dataItem->scaledParticleRadiusLocation, scaledParticleRadius);
glUniform1iARB(dataItem->tex0Location, 0);
}
else
{
glPointSize(particleRadius
* Vrui::getNavigationTransformation().getScaling());
GLfloat linear[3]= { 0.0, 1 / 5.0, 0.0 };
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, linear);
//
// NOTE::the following scaling calculation does not work properly
// in the CAVE. This is due to changes in the OpenGL library and
// cannot be fixed. On a 2D screen the scaling should look correct.
//
// Query the OpenGL viewing frustum
GLFrustum<float> frustum;
frustum.setFromGL();
// Calculate the nominal pixel size for particles
float pointSizeCounter=frustum.getPixelSize() * 2.0f * particleRadius;
float pointSizeDenominator=frustum.getEyeScreenDistance();
// Query the maximum point size accepted by glPointSize(...)
GLfloat pointSizeRange[2];
glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, pointSizeRange);
// Enable point parameters
glPointSize(pointSizeRange[1]); // select the maximum point size
pointSizeCounter/=pointSizeRange[1]; // adjust the point size numerator
GLfloat attenuation[3]= { 0.0f, 0.0f, 0.0f };
attenuation[2]=Math::sqr(pointSizeDenominator / pointSizeCounter);
glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, attenuation);
}
glBindBufferARB(GL_ARRAY_BUFFER_ARB, dataItem->vertexBufferId);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// If data has been modified, send to graphics card
if (dataItem->versionDS != data.currentVersion)
{
dataItem->numParticlesDS = data.numPoints;
glBufferDataARB(GL_ARRAY_BUFFER_ARB, dataItem->numParticlesDS
* sizeof(ColorPoint), &data.particles[0], GL_DYNAMIC_DRAW_ARB);
dataItem->versionDS = data.currentVersion;
}
glInterleavedArrays(GL_C4UB_V3F, sizeof(ColorPoint), 0);
glDrawArrays(GL_POINTS, 0, dataItem->numParticlesDS);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
#ifndef GHETTO
if (dataItem->hasShaders)
#endif
{
glUseProgramObjectARB(0);
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
}
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_POINT_SPRITE_ARB);
glDisable(GL_BLEND);
// restore previous attribute state
glPopAttrib();
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBPointParameters_nglPointParameterfvARB(JNIEnv *env, jclass clazz, jint pname, jlong pfParams, jlong function_pointer) {
const GLfloat *pfParams_address = (const GLfloat *)(intptr_t)pfParams;
glPointParameterfvARBPROC glPointParameterfvARB = (glPointParameterfvARBPROC)((intptr_t)function_pointer);
glPointParameterfvARB(pname, pfParams_address);
}
