/*
This draws all the particles shown on screen
*/
void
drawParticles()
{
/* draw the background */
glClear(GL_COLOR_BUFFER_BIT);
/* set up the position and color pointers */
glVertexPointer(2, GL_FLOAT, sizeof(struct particle), particles);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(struct particle),
particles[0].color);
if (pointSizeExtensionSupported) {
/* pass in our array of point sizes */
glPointSizePointerOES(GL_FLOAT, sizeof(struct particle),
&(particles[0].size));
}
/* draw our particles! */
glDrawArrays(GL_POINTS, 0, num_active_particles);
/* update screen */
SDL_RenderPresent();
}
void ofxParticleEmitter::drawPointsOES()
{
#ifdef TARGET_OF_IPHONE
// Disable the texture coord array so that texture information is not copied over when rendering
// the point sprites.
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// Bind to the verticesID VBO and popuate it with the necessary vertex & color informaiton
glBindBuffer(GL_ARRAY_BUFFER, verticesID);
glBufferData(GL_ARRAY_BUFFER, sizeof(PointSprite) * maxParticles, vertices, GL_DYNAMIC_DRAW);
// Configure the vertex pointer which will use the currently bound VBO for its data
glVertexPointer(2, GL_FLOAT, sizeof(PointSprite), 0);
glColorPointer(4,GL_FLOAT,sizeof(PointSprite),(GLvoid*) (sizeof(GLfloat)*3));
// Bind to the particles texture
glBindTexture(GL_TEXTURE_2D, (GLuint)textureData.textureID);
// Enable the point size array
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
// Configure the point size pointer which will use the currently bound VBO. PointSprite contains
// both the location of the point as well as its size, so the config below tells the point size
// pointer where in the currently bound VBO it can find the size for each point
glPointSizePointerOES(GL_FLOAT,sizeof(PointSprite),(GLvoid*) (sizeof(GL_FLOAT)*2));
// Change the blend function used if blendAdditive has been set
// Set the blend function based on the configuration
glBlendFunc(blendFuncSource, blendFuncDestination);
// Enable and configure point sprites which we are going to use for our particles
glEnable(GL_POINT_SPRITE_OES);
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
// Now that all of the VBOs have been used to configure the vertices, pointer size and color
// use glDrawArrays to draw the points
glDrawArrays(GL_POINTS, 0, particleIndex);
// Unbind the current VBO
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Disable the client states which have been used incase the next draw function does
// not need or use them
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisable(GL_POINT_SPRITE_OES);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Re-enable the texture coordinates as we use them elsewhere in the game and it is expected that
// its on
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
}
void CCParticleSystemPoint::draw(RenderContext* ctx)
{
CCParticleSystem::draw(ctx);
if (m_uParticleIdx == 0) return;
if (!activateBuffers(ctx)) return;
// Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
// Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY
// Unneeded states: GL_TEXTURE_COORD_ARRAY
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glBindTexture(GL_TEXTURE_2D, m_pTexture->activate(ctx));
glEnable(GL_POINT_SPRITE_OES);
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
#define kPointSize sizeof(m_pVertices[0])
glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuf->useHandle(ctx));
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(ccPointSprite)*m_uParticleCount, m_pVertices);
glVertexPointer(2,GL_FLOAT,kPointSize,0);
glColorPointer(4, GL_UNSIGNED_BYTE, kPointSize,(GLvoid*)offsetof(ccPointSprite,color) );
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
glPointSizePointerOES(GL_FLOAT,kPointSize,(GLvoid*) offsetof(ccPointSprite,size) );
bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false;
if( newBlend )
{
glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );
}
glDrawArrays(GL_POINTS, 0, m_uParticleIdx);
// restore blend state
if( newBlend )
glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST);
// unbind VBO buffer
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisable(GL_POINT_SPRITE_OES);
// restore GL default state
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
void GL11Renderer::Render() const
{
// Doodle jump sky color (or something like it).
glClearColor( 0.31f, 0.43f, 0.63f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glPushMatrix();
//
// Render our snow flakes as a VBO of point sprites...
//
// We don't care about depth for point sprites.
glDepthMask( GL_FALSE ); // Turn off depth writes
glEnable( GL_BLEND );
glEnable( GL_POINT_SPRITE_OES );
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glEnableClientState( GL_POINT_SIZE_ARRAY_OES );
glBindBuffer( GL_ARRAY_BUFFER, m_vertexBufferId );
glBufferSubData( GL_ARRAY_BUFFER, 0, MaxSnowFlakes * 2 * sizeof(float), m_pos );
glVertexPointer( 2, GL_FLOAT, 0, 0 );
glBindBuffer( GL_ARRAY_BUFFER, m_colorBufferId );
glBufferSubData( GL_ARRAY_BUFFER, 0, MaxSnowFlakes * 4 * sizeof(float), m_col );
glColorPointer( 4, GL_FLOAT, 0, 0 );
glBindBuffer( GL_ARRAY_BUFFER, m_pointSizeBufferId );
glBufferSubData( GL_ARRAY_BUFFER, 0, MaxSnowFlakes * sizeof(float), m_size );
glPointSizePointerOES( GL_FLOAT, sizeof(GL_FLOAT), (GLvoid*)(sizeof(GL_FLOAT)));
glDrawArrays( GL_POINTS, 0, MaxSnowFlakes );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glDisableClientState( GL_VERTEX_ARRAY );
glDisableClientState( GL_COLOR_ARRAY );
glDisableClientState( GL_POINT_SIZE_ARRAY_OES );
// Restore the OpenGL state:
glDisable( GL_BLEND );
glDisable( GL_POINT_SPRITE_OES );
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_FALSE );
glDepthMask( GL_TRUE ); // Turn back on depth writes
glPopMatrix();
}
void wyPointParticleSystem::draw() {
// if no draw flag is set, call wyNode::draw and it
// will decide forward drawing to java layer or not
if(m_noDraw) {
wyNode::draw();
return;
}
if(m_particleIdx == 0)
return;
if(m_tex != NULL) {
m_tex->load();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_tex->getTexture());
}
glEnable(GL_POINT_SPRITE_OES);
glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE);
glVertexPointer(2, GL_FLOAT, 0, m_vertices);
glColorPointer(4, GL_FLOAT, 0, m_colors);
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
glPointSizePointerOES(GL_FLOAT, 0, m_sizes);
bool newBlend = false;
if(m_blendFunc.src != DEFAULT_BLEND_SRC || m_blendFunc.dst != DEFAULT_BLEND_DST) {
newBlend = true;
glBlendFunc(m_blendFunc.src, m_blendFunc.dst);
}
glDrawArrays(GL_POINTS, 0, m_particleIdx);
// restore blend state
if(newBlend)
glBlendFunc(DEFAULT_BLEND_SRC, DEFAULT_BLEND_DST);
if(m_tex != NULL) {
glDisable(GL_TEXTURE_2D);
}
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisable(GL_POINT_SPRITE_OES);
}
/*!****************************************************************************
@Function RenderParticle
@Input NmbrOfParticles number of particles to initialize
@Input bReflect should we use the reflection colour ?
@Description Renders the specified set of particles, optionally using the
reflection colour.
******************************************************************************/
void OGLESParticles::RenderParticle(int i32ParticleNo, bool bReflect)
{
// If point sprites are availables, use them to draw the particles.
glBindBuffer(GL_ARRAY_BUFFER, m_i32VertVboID);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,VERTTYPEENUM, sizeof(SVtxPointSprite), 0);
myglTexEnv( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
glPointSizePointerOES(VERTTYPEENUM, sizeof(SVtxPointSprite),(GLvoid*) (sizeof(VERTTYPE)*3));
#ifndef PVRT_FIXED_POINT_ENABLE
float fCoefs[4] = { 0, 0, m_fPointAttenuationCoef, 0 };
#else
// Note: m_fPointAttenuationCoef will be too small to represent as a fixed point number,
// So use an approximation to the attenuation (fixed attenuation of 0.01) instead.
VERTTYPE fCoefs[4] = { f2vt(0.01f), f2vt(0.0f), f2vt(0.0f), f2vt(0.0f) };
#endif
myglPointParameterv(GL_POINT_DISTANCE_ATTENUATION, fCoefs);
glEnableClientState(GL_COLOR_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, bReflect ? m_i32ColBVboID : m_i32ColAVboID);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
glDrawArrays(GL_POINTS, 0, i32ParticleNo);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisableClientState(GL_COLOR_ARRAY);
}
void CCParticleSystemPoint::draw()
{
CCParticleSystem::draw();
if (m_uParticleIdx==0)
{
return;
}
// Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
// Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY
// Unneeded states: GL_TEXTURE_COORD_ARRAY
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glBindTexture(GL_TEXTURE_2D, m_pTexture->getName());
glEnable(GL_POINT_SPRITE_OES);
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
#define kPointSize sizeof(m_pVertices[0])
#if CC_USES_VBO
glBindBuffer(GL_ARRAY_BUFFER, m_uVerticesID);
#if CC_ENABLE_CACHE_TEXTTURE_DATA
glBufferData(GL_ARRAY_BUFFER, sizeof(ccPointSprite)*m_uTotalParticles, m_pVertices, GL_DYNAMIC_DRAW);
#endif
glVertexPointer(2,GL_FLOAT,kPointSize,0);
glColorPointer(4, GL_UNSIGNED_BYTE, kPointSize,(GLvoid*)offsetof(ccPointSprite,color) );
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
glPointSizePointerOES(GL_FLOAT,kPointSize,(GLvoid*) offsetof(ccPointSprite,size) );
#else // Uses Vertex Array List
int offset = (int)m_pVertices;
glVertexPointer(2,GL_FLOAT, kPointSize, (GLvoid*) offset);
int diff = offsetof(ccPointSprite, color);
glColorPointer(4, GL_UNSIGNED_BYTE, kPointSize, (GLvoid*) (offset+diff));
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
diff = offsetof(ccPointSprite, size);
glPointSizePointerOES(GL_FLOAT, kPointSize, (GLvoid*) (offset+diff));
#endif
bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false;
if( newBlend )
{
glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );
}
glDrawArrays(GL_POINTS, 0, m_uParticleIdx);
// restore blend state
if( newBlend )
glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST);
#if CC_USES_VBO
// unbind VBO buffer
glBindBuffer(GL_ARRAY_BUFFER, 0);
#endif
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisable(GL_POINT_SPRITE_OES);
// restore GL default state
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
void glPointSizePointerOESLogged(GLenum type, GLsizei stride, const GLvoid *pointer) {
printf("glPointSizePointerOES(%s, %i, %p)\n", GLEnumName(type), stride, pointer);
PrintGLData(1, type, stride, kPrintGLDataVertexCount, pointer);
glPointSizePointerOES(type, stride, pointer);
}
int main(int argc, char **argv)
#endif
{
GLuint ui32Vbo = 0; // Vertex buffer object handle
GLuint ui32IndexVbo;
GLuint ui32Texture;
int nframes = 100;
bool immidateMode = false;
bool useIndices = true;
bool useTexture = false;
bool useCompTexture = false;
bool useConvertedType = true;
bool useFixed = false;
bool usePoints = false;
bool useCopy = false;
bool useSubCopy = false;
int c;
extern char *optarg;
#ifdef _WIN32
HWND windowId = NULL;
#elif __linux__
Window windowId = NULL;
#elif __APPLE__
void* windowId = NULL;
#endif
// // Inialize SDL window
//
if (SDL_Init(SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO)) {
fprintf(stderr,"SDL init failed: %s\n", SDL_GetError());
return -1;
}
SDL_Surface *surface = SDL_SetVideoMode(WINDOW_WIDTH,WINDOW_HEIGHT, 32, SDL_HWSURFACE);
if (surface == NULL) {
fprintf(stderr,"Failed to set video mode: %s\n", SDL_GetError());
return -1;
}
SDL_SysWMinfo wminfo;
memset(&wminfo, 0, sizeof(wminfo));
SDL_GetWMInfo(&wminfo);
#ifdef _WIN32
windowId = wminfo.window;
#elif __linux__
windowId = wminfo.info.x11.window;
#elif __APPLE__
windowId = createGLView(wminfo.nsWindowPtr,0,0,WINDOW_WIDTH,WINDOW_HEIGHT);
#endif
int major,minor,num_config;
EGLConfig configs[150];
EGLSurface egl_surface;
EGLContext ctx;
EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(d,&major,&minor);
printf("DISPLAY == %p major =%d minor = %d\n",d,major,minor);
eglChooseConfig(d, attribute_list, configs, 150, &num_config);
printf("config returned %d\n",num_config);
egl_surface = eglCreateWindowSurface(d,configs[0],windowId,NULL);
printf("before creating context..\n");
ctx = eglCreateContext(d,configs[0],EGL_NO_CONTEXT,NULL);
printf("SURFACE == %p CONTEXT == %p\n",egl_surface,ctx);
if(eglMakeCurrent(d,egl_surface,egl_surface,ctx)!= EGL_TRUE){
printf("make current failed\n");
return false;
}
printf("after make current\n");
GLenum err = glGetError();
if(err != GL_NO_ERROR) {
printf("error before drawing ->>> %d \n",err);
} else {
printf("no error before drawing\n");
}
if (useTexture) {
glEnable(GL_TEXTURE_2D);
ui32Texture = 1;
glBindTexture(GL_TEXTURE_2D, ui32Texture);
GLenum err = glGetError();
unsigned char *pixels = NULL;
if(useCompTexture) {
pixels = genPalette4_rgb8(TEX_WIDTH,TEX_HEIGHT,3);
glCompressedTexImage2D(GL_TEXTURE_2D,0,GL_PALETTE4_RGB8_OES,TEX_WIDTH,TEX_HEIGHT,0,3*16+TEX_WIDTH*TEX_HEIGHT/2,pixels);
} else {
pixels = genTexture(TEX_WIDTH, TEX_HEIGHT, 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
}
delete pixels;
err = glGetError();
if(err != GL_NO_ERROR)
printf("error %d after image \n",err);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
err = glGetError();
if(err != GL_NO_ERROR)
printf("error after min filter \n");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
err = glGetError();
if(err != GL_NO_ERROR)
printf("error after mag filter \n");
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
err = glGetError();
if(err != GL_NO_ERROR)
printf("error after env mode \n");
if(useCompTexture) {
pixels = genPalette4_rgb8(TEX_WIDTH,TEX_HEIGHT,1);
glCompressedTexSubImage2D(GL_TEXTURE_2D,0,TEX_WIDTH/4,TEX_HEIGHT/4,TEX_WIDTH/8,TEX_HEIGHT/8,GL_PALETTE4_RGB8_OES,3*16+(TEX_WIDTH*TEX_HEIGHT/128),pixels);
} else {
pixels = genRedTexture(TEX_WIDTH/8, TEX_HEIGHT/8, 4);
glTexSubImage2D(GL_TEXTURE_2D,0,TEX_WIDTH/4,TEX_HEIGHT/4,TEX_WIDTH/8,TEX_HEIGHT/8,GL_RGBA,GL_UNSIGNED_BYTE,pixels);
}
err = glGetError();
if(err != GL_NO_ERROR)
printf("error %d after subimage \n",err);
delete pixels;
}
glClearColor(0.6f, 0.8f, 1.0f, 1.0f); // clear blue
float afVertices[] = { -0.4f,-0.4f,0.0f, // Position
1.0f,0.0f,0.0f,1.0f, // Color
0.0f, 0.0f, // texture
12.f, //point size
0.4f,-0.4f,0.0f,
0.0f,1.0f,0.0f,1.0f,
1.0f, 0.0f,
47.0f,
0.0f,0.4f,0.0f,
0.0f,0.0f,1.0f,1.0f,
0.5f, 1.0f,
14.0f
};
#define MAX_T 1
#define MID_T 0
#define MIN_T 0
GLbyte byteVertices[] = { -1,-1,0, // Position
255,0,0,255, // Color
MIN_T, MIN_T, // texture
12, //point size
1,-1,0,
0,255,0,255,
MAX_T,MIN_T,
47,
0,1,0,
0,0,255,255,
MID_T, MAX_T,
14
};
GLfixed fixedVertices[] = { F_to_X(-0.4f),F_to_X(-0.4f),F_to_X(0.0f), // Position
F_to_X(1.0f),F_to_X(0.0f),F_to_X(0.0f),F_to_X(1.0f), // Color
F_to_X(0.0f),F_to_X(0.0f), // texture
F_to_X(12.0f),//points size
F_to_X(0.4f),F_to_X(-0.4f),F_to_X(0.0f),
F_to_X(0.0f),F_to_X(1.0f),F_to_X(0.0f),F_to_X(1.0f),
F_to_X(1.0f),F_to_X( 0.0f),
F_to_X(30.0f),
F_to_X(0.0f),F_to_X(0.4f),F_to_X(0.0f),
F_to_X(0.0f),F_to_X(0.0f),F_to_X(1.0f),F_to_X(1.0f),
F_to_X(0.5f), F_to_X(1.0f),
F_to_X(30.0)
};
unsigned short indices[] = { 2, 1, 0 };
if (!immidateMode) {
glGenBuffers(1, &ui32Vbo);
ui32Vbo = 1;
printf("ui32Vbo = %d\n", ui32Vbo);
glBindBuffer(GL_ARRAY_BUFFER, ui32Vbo);
void* data = (void*)afVertices;
unsigned int uiSize = 3*(sizeof(float)*10);
if(useConvertedType){
if(useFixed){
data = (void*)fixedVertices;
} else {
data = (void*)byteVertices;
uiSize = 3*(sizeof(GLbyte)*10);
}
}
glBufferData(GL_ARRAY_BUFFER, uiSize,data, GL_STATIC_DRAW);
ui32IndexVbo = 2;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ui32IndexVbo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
}
// Draws a triangle for 800 frames
float angle = 0.0;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GLvoid* arr = NULL;
GLenum type;
GLenum drawType;
GLenum colorType;
int size_of;
if(useConvertedType){
if(useFixed)
{
arr = fixedVertices;
colorType = type = GL_FIXED;
size_of = sizeof(GLfixed);
} else {
arr = byteVertices;
colorType = GL_UNSIGNED_BYTE;
type = GL_BYTE;
size_of = sizeof(GLbyte);
}
}else {
arr = afVertices;
colorType = type = GL_FLOAT;
size_of = sizeof(float);
}
if(usePoints)
{
drawType = GL_POINTS;
}
else
drawType = GL_TRIANGLES;
GLvoid* data = NULL;
for (int i = 0; i < 100; i++) {
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(angle, 0.0, 0.0, 1.0);
angle += 360.0 / nframes;
// Enable vertex arrays
glEnableClientState(GL_VERTEX_ARRAY);
if (immidateMode) {
glVertexPointer(3,type, size_of * 10, arr);
} else {
glVertexPointer(3,type, size_of * 10, 0);
}
// Set color data in the same way
glEnableClientState(GL_COLOR_ARRAY);
if (immidateMode) {
SWITCH_SOURCE(3)
glColorPointer(4, colorType, size_of * 10, data);
} else {
glColorPointer(4,colorType,size_of * 10, (GLvoid*) (size_of * 3) );
}
if (useTexture) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (immidateMode) {
SWITCH_SOURCE(7)
glTexCoordPointer(2, type, size_of * 10,data);
} else {
glTexCoordPointer(2, type, size_of * 10, (GLvoid*)(size_of * 7));
}
}
if(usePoints)
{
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
if (immidateMode) {
SWITCH_SOURCE(9)
glPointSizePointerOES(type,size_of * 10,data);
} else {
glPointSizePointerOES(type,size_of * 10,(GLvoid*)(size_of * 9));
}
}
if (useIndices) {
if (immidateMode) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDrawElements(drawType, 3, GL_UNSIGNED_SHORT, indices);
} else {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ui32IndexVbo);
glDrawElements(drawType, 3, GL_UNSIGNED_SHORT, 0);
}
} else {
glDrawArrays(drawType, 0, 3);
}
GLenum err = glGetError();
if(err != GL_NO_ERROR)
printf(" error %d has occured while drawing\n",err);
glPopMatrix();
eglSwapBuffers(d,egl_surface);
if(useTexture && useCopy)
glCopyTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,0,0,256,256,0);
else if(useTexture && useSubCopy)
glCopyTexSubImage2D(GL_TEXTURE_2D,0,100,100,WINDOW_WIDTH/2,WINDOW_HEIGHT/2,50,50);
}
err = glGetError();
if(err != GL_NO_ERROR)
printf("error ->>> %d \n",err);
eglDestroySurface(d,egl_surface);
eglDestroyContext(d,ctx);
// Just wait until the window is closed
SDL_Event ev;
while( SDL_WaitEvent(&ev) ) {
if (ev.type == SDL_QUIT) {
break;
}
}
return 0;
}
void L_ParticleEffect::RenderPointSprites(SurfaceAnim *pSurf, int start, int count)
{
pSurf->Bind();
glBlendFunc( GL_SRC_ALPHA, GL_ONE);
//this point sprite code was based on code from http://www.71squared.com/2009/05/iphone-game-programming-tutorial-8-particle-emitter/ which
//was based on some cocos2d code I think -Seth
glBindBuffer(GL_ARRAY_BUFFER, L_ParticleMem::pointSpriteBufferID);
CHECK_GL_ERROR();
glBufferData(GL_ARRAY_BUFFER, sizeof(PointSprite)*count, &L_ParticleMem::pointSpriteArray[0], GL_DYNAMIC_DRAW);
CHECK_GL_ERROR();
glEnable(GL_BLEND);
// Enable and configure point sprites which we are going to use for our particles
glEnable(GL_POINT_SPRITE_OES);
CHECK_GL_ERROR();
glTexEnvi( GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE );
CHECK_GL_ERROR();
// Enable vertex arrays and bind to the vertices VBO which has been created
glEnableClientState(GL_VERTEX_ARRAY);
CHECK_GL_ERROR();
glBindBuffer(GL_ARRAY_BUFFER, L_ParticleMem::pointSpriteBufferID);
CHECK_GL_ERROR();
// Configure the vertex pointer which will use the vertices VBO
glVertexPointer(2, GL_FLOAT, sizeof(PointSprite), 0);
CHECK_GL_ERROR();
// Enable the point size array
glEnableClientState(GL_POINT_SIZE_ARRAY_OES);
// Configure the point size pointer which will use the currently bound VBO. PointSprite contains
// both the location of the point as well as its size, so the config below tells the point size
// pointer where in the currently bound VBO it can find the size for each point
glPointSizePointerOES(GL_FLOAT,sizeof(PointSprite),(GLvoid*) (sizeof(GL_FLOAT)*2));
// Enable the use of the color array
glEnableClientState(GL_COLOR_ARRAY);
// Configure the color pointer specifying how many values there are for each color and their type
glColorPointer(4,GL_UNSIGNED_BYTE,sizeof(PointSprite),(GLvoid*) (sizeof(GL_FLOAT)*3));
// Now that all of the VBOs have been used to configure the vertices, pointer size and color
// use glDrawArrays to draw the points
//NOTE: It crashes here on the WebOS GLES windows emulator .. but runs on the device. driver bug I guess -Seth
//Another note: It also can crash a Touchpad so.. not going to use this optimized point sprite stuff for webos :(
glDrawArrays(GL_POINTS, start, count);
CHECK_GL_ERROR();
// Unbind the current VBO
glBindBuffer(GL_ARRAY_BUFFER, 0);
CHECK_GL_ERROR();
// Disable the client states which have been used incase the next draw function does
// not need or use them
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisableClientState(GL_COLOR_ARRAY);
CHECK_GL_ERROR();
glDisable(GL_POINT_SPRITE_OES);
CHECK_GL_ERROR();
glDisableClientState(GL_POINT_SIZE_ARRAY_OES);
glDisableClientState(GL_COLOR_ARRAY);
CHECK_GL_ERROR();
glDisable(GL_POINT_SPRITE_OES);
glDisable(GL_BLEND);
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
CHECK_GL_ERROR();
}