void Device::draw_pixels(device_memory& rgba, int y, int w, int h, int dx, int dy, int width, int height, bool transparent,
const DeviceDrawParams &draw_params)
{
pixels_copy_from(rgba, y, w, h);
if(transparent) {
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
glColor3f(1.0f, 1.0f, 1.0f);
if(rgba.data_type == TYPE_HALF) {
/* for multi devices, this assumes the inefficient method that we allocate
* all pixels on the device even though we only render to a subset */
GLhalf *data_pointer = (GLhalf*)rgba.data_pointer;
float vbuffer[16], *basep;
float *vp = NULL;
data_pointer += 4*y*w;
/* draw half float texture, GLSL shader for display transform assumed to be bound */
GLuint texid;
glGenTextures(1, &texid);
glBindTexture(GL_TEXTURE_2D, texid);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, w, h, 0, GL_RGBA, GL_HALF_FLOAT, data_pointer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEnable(GL_TEXTURE_2D);
if(draw_params.bind_display_space_shader_cb) {
draw_params.bind_display_space_shader_cb();
}
if(GLEW_VERSION_1_5) {
if(!vertex_buffer)
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
/* invalidate old contents - avoids stalling if buffer is still waiting in queue to be rendered */
glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(float), NULL, GL_STREAM_DRAW);
vp = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
basep = NULL;
}
else {
basep = vbuffer;
vp = vbuffer;
}
if(vp) {
/* texture coordinate - vertex pair */
vp[0] = 0.0f;
vp[1] = 0.0f;
vp[2] = dx;
vp[3] = dy;
vp[4] = 1.0f;
vp[5] = 0.0f;
vp[6] = (float)width + dx;
vp[7] = dy;
vp[8] = 1.0f;
vp[9] = 1.0f;
vp[10] = (float)width + dx;
vp[11] = (float)height + dy;
vp[12] = 0.0f;
vp[13] = 1.0f;
vp[14] = dx;
vp[15] = (float)height + dy;
if(vertex_buffer)
glUnmapBuffer(GL_ARRAY_BUFFER);
}
glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), basep);
glVertexPointer(2, GL_FLOAT, 4 * sizeof(float), ((char *)basep) + 2 * sizeof(float));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
if(vertex_buffer) {
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
if(draw_params.unbind_display_space_shader_cb) {
draw_params.unbind_display_space_shader_cb();
}
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(1, &texid);
}
else {
/* fallback for old graphics cards that don't support GLSL, half float,
* and non-power-of-two textures */
glPixelZoom((float)width/(float)w, (float)height/(float)h);
glRasterPos2f(dx, dy);
uint8_t *pixels = (uint8_t*)rgba.data_pointer;
pixels += 4*y*w;
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
glRasterPos2f(0.0f, 0.0f);
glPixelZoom(1.0f, 1.0f);
}
if(transparent)
glDisable(GL_BLEND);
}
void SS3OPiece::DrawForList() const
{
if (!hasGeometryData)
return;
vboAttributes.Bind(GL_ARRAY_BUFFER);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, pos)));
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, normal)));
glClientActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, texCoord)));
glClientActiveTexture(GL_TEXTURE1);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, texCoord)));
glClientActiveTexture(GL_TEXTURE5);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, sTangent)));
glClientActiveTexture(GL_TEXTURE6);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(SS3OVertex), vboAttributes.GetPtr(offsetof(SS3OVertex, tTangent)));
vboAttributes.Unbind();
vboIndices.Bind(GL_ELEMENT_ARRAY_BUFFER);
switch (primType) {
case S3O_PRIMTYPE_TRIANGLES: {
glDrawRangeElements(GL_TRIANGLES, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr());
} break;
case S3O_PRIMTYPE_TRIANGLE_STRIP: {
#ifdef GLEW_NV_primitive_restart
if (globalRendering->supportRestartPrimitive) {
// this is not compiled into display lists, but executed immediately
glPrimitiveRestartIndexNV(-1U);
glEnableClientState(GL_PRIMITIVE_RESTART_NV);
}
#endif
glDrawRangeElements(GL_TRIANGLE_STRIP, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr());
#ifdef GLEW_NV_primitive_restart
if (globalRendering->supportRestartPrimitive) {
glDisableClientState(GL_PRIMITIVE_RESTART_NV);
}
#endif
} break;
case S3O_PRIMTYPE_QUADS: {
glDrawRangeElements(GL_QUADS, 0, vertices.size() - 1, vertexDrawIndices.size(), GL_UNSIGNED_INT, vboIndices.GetPtr());
} break;
}
vboIndices.Unbind();
glClientActiveTexture(GL_TEXTURE6);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE5);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE1);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
// DRAW A TEXTURE INTO THE THE SHARED TEXTURE VIA AN FBO
bool spoutGLDXinterop::DrawToSharedTexture(GLuint TextureID, GLuint TextureTarget, unsigned int width, unsigned int height, float max_x, float max_y, float aspect, bool bInvert, GLuint HostFBO)
{
if(m_hInteropDevice == NULL || m_hInteropObject == NULL) {
return false;
}
if(width != (unsigned int)m_TextureInfo.width || height != (unsigned int)m_TextureInfo.height) {
return false;
}
// Wait for access to the texture
if(spoutdx.CheckAccess(m_hAccessMutex, g_pSharedTexture)) {
if(LockInteropObject(m_hInteropDevice, &m_hInteropObject) == S_OK) {
// Draw the input texture into the shared texture via an fbo
// Bind our fbo
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
glFramebufferTexture2DEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_glTexture, 0);
glBindTexture(GL_TEXTURE_2D, m_glTexture);
glColor4f(1.f, 1.f, 1.f, 1.f);
glEnable(TextureTarget);
glBindTexture(TextureTarget, TextureID);
GLfloat tc[4][2] = {0};
if(bInvert) {
tc[0][0] = 0.0; tc[0][1] = max_y;
tc[1][0] = 0.0; tc[1][1] = 0.0;
tc[2][0] = max_x; tc[2][1] = 0.0;
tc[3][0] = max_x; tc[3][1] = max_y;
}
else {
tc[0][0] = 0.0; tc[0][1] = 0.0;
tc[1][0] = 0.0; tc[1][1] = max_y;
tc[2][0] = max_x; tc[2][1] = max_y;
tc[3][0] = max_x; tc[3][1] = 0.0;
}
GLfloat verts[] = {
-aspect, -1.0, // bottom left
-aspect, 1.0, // top left
aspect, 1.0, // top right
aspect, -1.0 }; // bottom right
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glTexCoordPointer(2, GL_FLOAT, 0, tc );
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, verts );
glDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glBindTexture(TextureTarget, 0);
glDisable(TextureTarget);
glBindTexture(GL_TEXTURE_2D, 0);
// restore the previous fbo - default is 0
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, HostFBO);
UnlockInteropObject(m_hInteropDevice, &m_hInteropObject);
}
}
spoutdx.AllowAccess(m_hAccessMutex, g_pSharedTexture); // Allow access to the texture
return true;
}
void FGAPIENTRY
glutSolidConex(GLfixed base, GLfixed height, GLint slices, GLint stacks)
{
GLint i, j;
float twopi, nx, ny, nz;
static GLfixed* v, *n;
static GLfixed parms[4];
GLfixed* p, *q;
float basef = _FIXED2FLOAT(base);
float heightf = _FIXED2FLOAT(height);
if (v)
{
if (parms[0] != base || parms[1] != height || parms[2] != slices || parms[3] != stacks)
{
free(v);
free(n);
n = v = 0;
glVertexPointer(3, GL_FIXED, 0, 0);
glNormalPointer(GL_FIXED, 0, 0);
}
}
if ((!v) && (height != 0))
{
float phi = (float)atan(basef/heightf);
float cphi = (float)cos(phi);
float sphi= (float)sin(phi);
parms[0] = base;
parms[1] = height;
parms[2] = (GLfixed)slices;
parms[3] = (GLfixed)stacks;
p = v = (GLfixed*)malloc(stacks*(slices+1)*2*3*sizeof *v);
q = n = (GLfixed*)malloc(stacks*(slices+1)*2*3*sizeof *n);
twopi = 2.0f * ((float)PI_);
for (i = 0; i < stacks; i++)
{
float r = basef * (1.f - (float) i / stacks);
float r1 = basef * (1.f - (float) (i + 1.f) / stacks);
float z = heightf * i /stacks;
float z1 = heightf * (1.f + i) / stacks;
for (j = 0; j <= slices; j++)
{
float theta = j == slices ? 0.f : (float) j / slices * twopi;
float ctheta = (float)cos(theta);
float stheta = (float)sin(theta);
nx = ctheta;
ny = stheta;
nz = sphi;
*p++ = _FLOAT2FIXED(r1 * nx);
*p++ = _FLOAT2FIXED(r1 * ny);
*p++ = _FLOAT2FIXED(z1);
*q++ = _FLOAT2FIXED(nx * cphi);
*q++ = _FLOAT2FIXED(ny * cphi);
*q++ = _FLOAT2FIXED(nz);
*p++ = _FLOAT2FIXED(r * nx);
*p++ = _FLOAT2FIXED(r * ny);
*p++ = _FLOAT2FIXED(z);
*q++ = _FLOAT2FIXED(nx * cphi);
*q++ = _FLOAT2FIXED(ny * cphi);
*q++ = _FLOAT2FIXED(nz);
}
}
}
glVertexPointer(3, GL_FIXED, 0, v);
glNormalPointer(GL_FIXED, 0, n);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
for(i = 0; i < stacks; i++)
glDrawArrays(GL_TRIANGLE_STRIP, i*(slices+1)*2, (slices+1)*2);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void FGAPIENTRY
glutSolidCubex(GLfixed size)
{
static GLfixed v[108]; // 108 = 6*18
static const int cubev[108] =
{
-1, -1, 1, /* front */
1, -1, 1,
-1, 1, 1,
1, -1, 1,
1, 1, 1,
-1, 1, 1,
-1, 1, -1, /* back */
1, -1, -1,
-1, -1, -1,
-1, 1, -1,
1, 1, -1,
1, -1, -1,
-1, -1, -1, /* left */
-1, -1, 1,
-1, 1, -1,
-1, -1, 1,
-1, 1, 1,
-1, 1, -1,
1, -1, 1, /* right */
1, -1, -1,
1, 1, 1,
1, -1, -1,
1, 1, -1,
1, 1, 1,
-1, 1, 1, /* top */
1, 1, 1,
-1, 1, -1,
1, 1, 1,
1, 1, -1,
-1, 1, -1,
-1, -1, -1, /* bottom */
1, -1, -1,
-1, -1, 1,
1, -1, -1,
1, -1, 1,
-1, -1, 1,
};
static const GLfixed cuben[108] =
{
0, 0, F1, /* front */
0, 0, F1,
0, 0, F1,
0, 0, F1,
0, 0, F1,
0, 0, F1,
0, 0, FM1, /* back */
0, 0, FM1,
0, 0, FM1,
0, 0, FM1,
0, 0, FM1,
0, 0, FM1,
FM1, 0, 0, /* left */
FM1, 0, 0,
FM1, 0, 0,
FM1, 0, 0,
FM1, 0, 0,
FM1, 0, 0,
F1, 0, 0, /* right */
F1, 0, 0,
F1, 0, 0,
F1, 0, 0,
F1, 0, 0,
F1, 0, 0,
0, F1, 0, /* top */
0, F1, 0,
0, F1, 0,
0, F1, 0,
0, F1, 0,
0, F1, 0,
0, FM1, 0, /* bottom */
0, FM1, 0,
0, FM1, 0,
0, FM1, 0,
0, FM1, 0,
0, FM1, 0,
};
int i;
size /= 2;
for(i = 0; i < 108; i++)
v[i] = cubev[i] * size;
glVertexPointer(3, GL_FIXED, 0, v);
glNormalPointer(GL_FIXED, 0, cuben);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
glDrawArrays(GL_TRIANGLES, 0, 36);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void RenderFXSpritesF(void)
{
int i,j;
/*
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
SetTextureF(smokeTexture.textureId);
if (numSmokeIndices != 0)
{
glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->text);
//glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), smokeVertices->color);
glDrawElements (GL_TRIANGLES, numSmokeIndices, GL_UNSIGNED_SHORT,smokeIndices);
STATS_AddTriangles(numSmokeIndices/3);
}
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
*/
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
SetTextureF(smokeTexture.textureId);
if (numSmokeIndices != 0)
{
glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), smokeVertices->text);
//glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), smokeVertices->color);
glDrawElements (GL_TRIANGLES, numSmokeIndices, GL_UNSIGNED_SHORT,smokeIndices);
STATS_AddTriangles(numSmokeIndices/3);
}
SetTextureF(ghostTexture.textureId);
for(i=0 ; i <numPlayers ; i++)
{
/*
if (i==0)
glColor4f(0.8f, 0.8f, 1.0f, 0.9f);
else {
glColor4f(1.0f, 0.4f, 0.4f, 0.9f);
}
*/
for (j=0; j< GHOSTS_NUM; j++)
{
if (players[i].ghosts[j].timeCounter >= GHOST_TTL_MS)
continue;
//vertices = &players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray];
glVertexPointer( 2, GL_SHORT, sizeof(xf_colorless_sprite_t), players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray].pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_colorless_sprite_t), players[i].ghosts[j].wayPoints[players[i].ghosts[j].startVertexArray].text);
//glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), vertices->color);
glDrawArrays(GL_TRIANGLE_STRIP, 0, players[i].ghosts[j].lengthVertexArray);
STATS_AddTriangles((players[i].ghosts[j].lengthVertexArray/2));
}
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnableClientState(GL_COLOR_ARRAY);
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//Render all particules
if (numParticulesIndices != 0)
{
SetTextureF(bulletConfig.bulletTexture.textureId);
glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), particuleVertices->pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), particuleVertices->text);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), particuleVertices->color);
glDrawElements (GL_TRIANGLES, numParticulesIndices, GL_UNSIGNED_SHORT,particuleIndices);
STATS_AddTriangles(numParticulesIndices/3);
}
//Render all explosions
if (numExplosionIndices != 0)
{
SetTextureF(explosionTexture.textureId);
glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), explosionVertices->pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), explosionVertices->text);
//printf("REMOVE COLOR INDICES EXPLOSIONS RenderFXSpritesF !!!! \n");
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), explosionVertices->color);
glDrawElements (GL_TRIANGLES, numExplosionIndices, GL_UNSIGNED_SHORT,explosionIndices);
STATS_AddTriangles(numExplosionIndices/3);
}
//Render enemy FXs
SetTextureF(bulletConfig.bulletTexture.textureId);
glVertexPointer( 2, GL_SHORT, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].pos);
glTexCoordPointer(2, GL_SHORT, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].text);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(xf_sprite_t), enFxLib.ss_vertices[0].color);
glDrawElements (GL_TRIANGLES, enFxLib.num_indices, GL_UNSIGNED_SHORT,enFxLib.indices);
STATS_AddTriangles(enFxLib.num_indices/3);
//printf("enFxLib.num_indices=%d\n",enFxLib.num_indices);
#ifdef RENDER_COLL_BOXEX
RenderCollisionBoxes();
#endif
//glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisableClientState(GL_COLOR_ARRAY);
}
void Waveform::Draw(RenderContext &context)
{
//if (samples > 2048) samples = 2048;
if (additive) glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (thick)
{
glLineWidth(context.texsize <= 512 ? 2 : 2*context.texsize/512);
glPointSize(context.texsize <= 512 ? 2 : 2*context.texsize/512);
}
else glPointSize(context.texsize <= 512 ? 1 : context.texsize/512);
float *value1 = new float[samples];
float *value2 = new float[samples];
context.beatDetect->pcm->getPCM( value1, samples, 0, spectrum, smoothing, 0);
context.beatDetect->pcm->getPCM( value2, samples, 1, spectrum, smoothing, 0);
// printf("%f\n",pcmL[0]);
float mult= scaling*( spectrum ? 0.015f :1.0f);
std::transform(&value1[0],&value1[samples],&value1[0],std::bind2nd(std::multiplies<float>(),mult));
std::transform(&value2[0],&value2[samples],&value2[0],std::bind2nd(std::multiplies<float>(),mult));
WaveformContext waveContext(samples, context.beatDetect);
for(int x=0;x< samples;x++)
{
waveContext.sample = x/(float)(samples - 1);
waveContext.sample_int = x;
waveContext.left = value1[x];
waveContext.right = value2[x];
points[x] = PerPoint(points[x],waveContext);
}
floatQuad *colors = new float[samples][4];
floatPair *p = new float[samples][2];
for(int x=0;x< samples;x++)
{
colors[x][0] = points[x].r;
colors[x][1] = points[x].g;
colors[x][2] = points[x].b;
colors[x][3] = points[x].a * masterAlpha;
p[x][0] = points[x].x;
p[x][1] = -(points[x].y-1);
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2,GL_FLOAT,0,p);
glColorPointer(4,GL_FLOAT,0,colors);
if (dots) glDrawArrays(GL_POINTS,0,samples);
else glDrawArrays(GL_LINE_STRIP,0,samples);
glPointSize(context.texsize < 512 ? 1 : context.texsize/512);
glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);
#ifndef USE_GLES1
glDisable(GL_LINE_STIPPLE);
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glPopMatrix();
delete[] colors;
delete[] p;
delete[] value1;
delete[] value2;
}
baiscobj::~baiscobj()
{ for(int i=0;i<16;i++) glDeleteTextures(1, &g_cactus[i]);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
void Model::DrawModel(bool drawWithNormals, bool drawWithTexture)
{
// Performs rotation of model
glRotatef(ModelRotation.x, 1, 0, 0);
glRotatef(ModelRotation.y, 0, 1, 0);
glRotatef(ModelRotation.z, 0, 0, 1);
// Scales model if necessary
glScalef(ModelScale.x,ModelScale.y,ModelScale.z);
// Translates model
glTranslatef(ModelPosition.x, ModelPosition.y, ModelPosition.z);
// activate and specify pointer to vertex array
glEnableClientState(GL_VERTEX_ARRAY);
vector<float>& vertices = m_modelReader->GetVertices();
glVertexPointer(3, GL_FLOAT, 0, &vertices[0]);
// pointer to normal array
if (drawWithNormals)
{
glEnableClientState(GL_NORMAL_ARRAY);
vector<float>&normals = m_modelReader->GetNormals();
glNormalPointer(GL_FLOAT, 0, &normals[0]);
}
if (drawWithTexture)
{
glEnable(GL_TEXTURE_2D);
vector<float>& textureCoordinates = m_modelReader->GetTextureCoordinates();
glBindTexture(GL_TEXTURE_2D, m_textureID);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, &textureCoordinates[0]);
}
// draw the shape...
glDrawArrays(GL_TRIANGLES, 0, (unsigned int)vertices.size() / 3);
// deactivate vertex arrays after drawing
glDisableClientState(GL_VERTEX_ARRAY);
if (drawWithNormals)
{
// deactivate
glDisableClientState(GL_NORMAL_ARRAY);
}
if (drawWithTexture)
{
glBindTexture(GL_TEXTURE_2D, NULL);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
}
}
void initFixedRenderer(renderer_t* renderer)
{
GLenum err;
char *extensionsList ;
//Log_Printf("[initFixedRenderer] has a nnnasty hack");
renderer->type = GL_11_RENDERER ;
//renderer->supportBumpMapping = 0;
renderer->props = 0;
renderer->Set3D = Set3DF;
renderer->StopRendition = StopRenditionF;
renderer->SetTexture = SetTextureF;
renderer->RenderEntities = RenderEntitiesF;
renderer->UpLoadTextureToGpu = UpLoadTextureToGPUF;
renderer->UpLoadEntityToGPU = UpLoadEntityToGPUF;
renderer->Set2D = Set2DF;
renderer->RenderPlayersBullets = RenderPlayersBulletsF ;
renderer->RenderString = RenderStringF;
renderer->GetColorBuffer = GetColorBufferF;
renderer->RenderFXSprites = RenderFXSpritesF;
renderer->DrawControls = DrawControlsF;
renderer->FreeGPUTexture = FreeGPUTextureF;
renderer->FreeGPUBuffer = FreeGPUBufferF;
renderer->UploadVerticesToGPU = UploadVerticesToGPUF;
renderer->StartCleanFrame = StartCleanFrameF;
renderer->RenderColorlessSprites = RenderColorlessSpritesF;
renderer->FadeScreen = FadeScreenF;
renderer->SetMaterialTextureBlending = SetMaterialTextureBlendingF;
renderer->SetTransparency = SetTransparencyF;
renderer->IsTextureCompressionSupported = IsTextureCompressionSupportedF;
renderer->RefreshViewPort = RefreshViewPortF;
glViewport(renderer->viewPortDimensions[VP_X],
renderer->viewPortDimensions[VP_Y],
renderer->viewPortDimensions[VP_WIDTH],
renderer->viewPortDimensions[VP_HEIGHT]);
glEnable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glClearColor(0, 0, 0,1.0f);
glColor4f(1.0f, 1.0f, 1.0f,1.0f);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(textureMatrix);
//We need to check what texture compression method is supported.
extensionsList = (char *) glGetString(GL_EXTENSIONS);
if (strstr(extensionsList,"GL_IMG_texture_compression_pvrtc"))
supportedCompressionFormatF |= TEXTURE_FORMAT_PVRTC ;
err = glGetError();
if (err != GL_NO_ERROR)
Log_Printf("Error initing 1.1: glError: 0x%04X", err);
}
inline void buffer<T>::unbind() const
{
glEnableClientState( m_state );
glBindBuffer( m_target, 0);
glDisableClientState( m_state );
}
void CpuClipmapRenderer::renderBlock( const GeometryClipmapLevel& level, const GeometryClipmapLevel* coarserLevel, const ClipmapRenderParameters& renderParameters, const Color3f& debugColor )
{
TerrainLevelRenderData& renderData = levels_[ level.index ];
if( renderData.indices.size() <= 0 )
{
return;
}
// enable the texture:
// todo: enable the texture of the next coarser level too, so we can blend between both
if( renderData.texture != NULL )
{
//renderData.texture->activate( renderParameters.renderAction );
}
Pnt2i transitionSize;
//transitionSize[ 0 ] = std::min( ( levelSampleCount_ / 10 ) * level.sampleDistance[ 0 ], level.minTransitionSize[ 0 ] );
//transitionSize[ 1 ] = std::min( ( levelSampleCount_ / 10 ) * level.sampleDistance[ 1 ], level.minTransitionSize[ 1 ] );
const int levelSampleSpacing = level.sampleSpacing;
transitionSize[ 0 ] = levelSampleSpacing * level.heightmap.size / 10;
transitionSize[ 1 ] = levelSampleSpacing * level.heightmap.size / 10;
// min and max are the first,last point inside the renderregion:
Pnt2f activeRegionMin = Pnt2f( level.sampleOrigin );
Pnt2f activeRegionMax = Pnt2f( componentAdd( level.sampleOrigin, Pnt2i( level.getSampleCoverage(), level.getSampleCoverage() ) ) );
Pnt2f worldTransitionSize = Pnt2f( transitionSize );
//Point2f activeRegionCenter = samplePosToWorldPos( level.outerRenderBounds.getTopLeft() + level.outerRenderBounds.getSize() / 2 );
//Point2f localViewerPos( worldViewerPosition_[ 0 ], worldViewerPosition_.z );
//Pnt2i viewerSamplePos = worldPosToSamplePos( localViewerPos );
//Point2f baseLocalViewerPos = samplePosToWorldPos( viewerSamplePos );
//localViewerPos -= baseLocalViewerPos;
#ifdef OLD_GEOCLIP
//beginEditCP( terrainShader_ );
terrainShader_.setUniform( "transitionWidth", Vec2f( worldTransitionSize ) );
terrainShader_.setUniform( "activeRegionMin", Vec2f( activeRegionMin ) );
terrainShader_.setUniform( "activeRegionMax", Vec2f( activeRegionMax ) );
//terrainShader_->setUniform( "activeRegionCenter", activeRegionCenter );
terrainShader_.setUniform( "localViewerPos", Vec3f( viewerPosition_ ) );
terrainShader_.setUniform( "baseColor0", colorToVector( debugColor ) );
//endEditCP( terrainShader_ );
#else
_pTerrainShader->addUniformVariable( "transitionWidth",
Vec2f( worldTransitionSize ) );
_pTerrainShader->addUniformVariable( "activeRegionMin",
Vec2f( activeRegionMin ) );
_pTerrainShader->addUniformVariable( "activeRegionMax",
Vec2f( activeRegionMax ) );
//terrainShader_->setUniform( "activeRegionCenter", activeRegionCenter );
_pTerrainShader->addUniformVariable( "localViewerPos",
Vec3f( viewerPosition_ ) );
#ifdef NOTUSED
_pTerrainShader->setUniformParameter( "baseColor0",
colorToVector( debugColor ) );
#endif
#endif
if( coarserLevel )
{
#ifdef OLD_GEOCLIP
terrainShader_.setUniform(
"baseColor1",
colorToVector( getDebugColor( coarserLevel->index ) ) );
#else
#ifdef NOTUSED
_pTerrainShader->setUniformParameter(
"baseColor1",
colorToVector( getDebugColor( coarserLevel->index ) ) );
#endif
#endif
}
else
{
#ifdef OLD_GEOCLIP
terrainShader_.setUniform(
"baseColor1",
colorToVector( debugColor ) );
#else
#ifdef NOTUSED
_pTerrainShader->setUniformParameter(
"baseColor1",
colorToVector( debugColor ) );
#endif
#endif
}
//terrainShader_->updateParameters( drawAction->getWindow(), terrainShader_->getParameters() );
if( renderParameters.useVboExtension && useVertexBufferObjects_ )
{
renderData.vertexBuffer.activate();
char* base = 0;
glVertexPointer( 4, GL_FLOAT, sizeof( OpenGLTerrainVertex ), base );
glEnableClientState( GL_VERTEX_ARRAY );
glTexCoordPointer( 2, GL_FLOAT, sizeof( OpenGLTerrainVertex ), base + sizeof( Pnt4f ) );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glDrawElements( GL_TRIANGLES, GLsizei(renderData.indices.size()),
GL_UNSIGNED_SHORT, &renderData.indices[ 0 ] );
renderData.vertexBuffer.deactivate();
}
else
{
glVertexPointer( 4, GL_FLOAT, sizeof( OpenGLTerrainVertex ), &renderData.vertices[ 0 ].pos );
glEnableClientState( GL_VERTEX_ARRAY );
glTexCoordPointer( 2, GL_FLOAT, sizeof( OpenGLTerrainVertex ), &renderData.vertices[ 0 ].uv );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glDrawElements( GL_TRIANGLES, GLsizei(renderData.indices.size()),
GL_UNSIGNED_SHORT, &renderData.indices[ 0 ] );
}
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
glDisableClientState( GL_NORMAL_ARRAY );
glDisableClientState( GL_VERTEX_ARRAY );
stats_.drawnBlockCount++;
stats_.drawnTriangleCount += int(renderData.indices.size()) / 3;
stats_.transformedVertexCount += int(renderData.vertices.size());
if( renderData.texture != NULL )
{
//renderData.texture->deactivate( renderParameters.renderAction );
}
}
void glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
{
__GLFBcontext *gc = __glFBGetCurrentContext();
GLboolean tEnable = GL_FALSE, cEnable = GL_FALSE, nEnable = GL_FALSE;
GLenum tType = GL_FLOAT, nType = GL_FLOAT, vType = GL_FLOAT;
GLenum cType = GL_FALSE;
GLint tSize = 0, cSize = 0, nSize = 3, vSize;
int cOffset = 0, nOffset = 0, vOffset = 0;
GLint trueStride, size;
switch (format) {
case GL_V2F:
vSize = 2;
size = __glFBTypeSize(vType) * vSize;
break;
case GL_V3F:
vSize = 3;
size = __glFBTypeSize(vType) * vSize;
break;
case GL_C4UB_V2F:
cEnable = GL_TRUE;
cSize = 4;
cType = GL_UNSIGNED_BYTE;
vSize = 2;
vOffset = __glFBTypeSize(cType) * cSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_C4UB_V3F:
cEnable = GL_TRUE;
cSize = 4;
cType = GL_UNSIGNED_BYTE;
vSize = 3;
vOffset = __glFBTypeSize(vType) * cSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_C3F_V3F:
cEnable = GL_TRUE;
cSize = 3;
cType = GL_FLOAT;
vSize = 3;
vOffset = __glFBTypeSize(cType) * cSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_N3F_V3F:
nEnable = GL_TRUE;
vSize = 3;
vOffset = __glFBTypeSize(nType) * nSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_C4F_N3F_V3F:
cEnable = GL_TRUE;
cSize = 4;
cType = GL_FLOAT;
nEnable = GL_TRUE;
nOffset = __glFBTypeSize(cType) * cSize;
vSize = 3;
vOffset = nOffset + __glFBTypeSize(nType) * nSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T2F_V3F:
tEnable = GL_TRUE;
tSize = 2;
vSize = 3;
vOffset = __glFBTypeSize(tType) * tSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T4F_V4F:
tEnable = GL_TRUE;
tSize = 4;
vSize = 4;
vOffset = __glFBTypeSize(tType) * tSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T2F_C4UB_V3F:
tEnable = GL_TRUE;
tSize = 2;
cEnable = GL_TRUE;
cSize = 4;
cType = GL_UNSIGNED_BYTE;
cOffset = __glFBTypeSize(tType) * tSize;
vSize = 3;
vOffset = cOffset + __glFBTypeSize(cType) * cSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T2F_C3F_V3F:
tEnable = GL_TRUE;
tSize = 2;
cEnable = GL_TRUE;
cSize = 3;
cType = GL_FLOAT;
cOffset = __glFBTypeSize(tType) * tSize;
vSize = 3;
vOffset = cOffset + __glFBTypeSize(cType) * cSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T2F_N3F_V3F:
tEnable = GL_TRUE;
tSize = 2;
nEnable = GL_TRUE;
nOffset = __glFBTypeSize(tType) * tSize;
vSize = 3;
vOffset = nOffset + __glFBTypeSize(nType) * nSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T2F_C4F_N3F_V3F:
tEnable = GL_TRUE;
tSize = 2;
cEnable = GL_TRUE;
cSize = 4;
cType = GL_FLOAT;
cOffset = __glFBTypeSize(tType) * tSize;
nEnable = GL_TRUE;
nOffset = cOffset + __glFBTypeSize(cType) * cSize;
vSize = 3;
vOffset = nOffset + __glFBTypeSize(nType) * nSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
case GL_T4F_C4F_N3F_V4F:
tEnable = GL_TRUE;
tSize = 4;
cEnable = GL_TRUE;
cSize = 4;
cType = GL_FLOAT;
cOffset = __glFBTypeSize(tType) * tSize;
nEnable = GL_TRUE;
nOffset = cOffset + __glFBTypeSize(cType) * cSize;
vSize = 4;
vOffset = nOffset + __glFBTypeSize(nType) * nSize;
size = vOffset + __glFBTypeSize(vType) * vSize;
break;
default:
__glFBSetError(gc, GL_INVALID_ENUM);
return;
}
trueStride = (stride == 0) ? size : stride;
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
if (tEnable) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(tSize, tType, trueStride, (const char *)pointer);
} else {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (cEnable) {
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(cSize, cType, trueStride, (const char *)pointer+cOffset);
} else {
glDisableClientState(GL_COLOR_ARRAY);
}
if (nEnable) {
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(nType, trueStride, (const char *)pointer+nOffset);
} else {
glDisableClientState(GL_NORMAL_ARRAY);
}
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(vSize, vType, trueStride, (const char *)pointer+vOffset);
}
PsychError SCREENDrawDots(void)
{
PsychWindowRecordType *windowRecord;
int whiteValue, m,n,p,mc,nc,pc,idot_type;
int i, nrpoints, nrsize;
boolean isArgThere, usecolorvector, isdoublecolors, isuint8colors;
double *xy, *size, *center, *dot_type, *colors;
unsigned char *bytecolors;
GLfloat pointsizerange[2];
double convfactor;
// All sub functions should have these two lines
PsychPushHelp(useString, synopsisString,seeAlsoString);
if(PsychIsGiveHelp()) {
PsychGiveHelp();
return(PsychError_none);
};
// Check for superfluous arguments
PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs
PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs
// Get the window record from the window record argument and get info from the window record
PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord);
// Query, allocate and copy in all vectors...
nrpoints = 2;
nrsize = 0;
colors = NULL;
bytecolors = NULL;
PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size);
isdoublecolors = (colors) ? TRUE:FALSE;
isuint8colors = (bytecolors) ? TRUE:FALSE;
usecolorvector = (nc>1) ? TRUE:FALSE;
// Get center argument
isArgThere = PsychIsArgPresent(PsychArgIn, 5);
if(!isArgThere) {
center = (double *) PsychMallocTemp(2 * sizeof(double));
center[0] = 0;
center[1] = 0;
} else {
PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er);
if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector");
}
// Get dot_type argument
isArgThere = PsychIsArgPresent(PsychArgIn, 6);
if(!isArgThere) {
idot_type = 0;
} else {
PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type);
if(p!=1 || n!=1 || m!=1 || (dot_type[0]<0 || dot_type[0]>2))
PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1 or 2");
idot_type = (int) dot_type[0];
}
// Child-protection: Alpha blending needs to be enabled for smoothing to work:
if (idot_type>0 && windowRecord->actualEnableBlending!=TRUE) {
PsychErrorExitMsg(PsychError_user, "Point smoothing doesn't work with alpha-blending disabled! See Screen('BlendFunction') on how to enable it.");
}
// Turn on antialiasing to draw circles
if(idot_type) {
glEnable(GL_POINT_SMOOTH);
glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
// A dot type of 2 requests for highest quality point smoothing:
glHint(GL_POINT_SMOOTH_HINT, (idot_type>1) ? GL_NICEST : GL_DONT_CARE);
}
else {
#ifndef GL_ALIASED_POINT_SIZE_RANGE
#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
#endif
glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange);
}
// Set size of a single dot:
if (size[0] > pointsizerange[1] || size[0] < pointsizerange[0]) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
size[0], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup initial common point size for all points:
glPointSize(size[0]);
// Setup modelview matrix to perform translation by 'center':
glMatrixMode(GL_MODELVIEW);
// Make a backup copy of the matrix:
glPushMatrix();
// Apply a global translation of (center(x,y)) pixels to all following points:
glTranslated(center[0], center[1], 0);
// Render the array of 2D-Points - Efficient version:
// This command sequence allows fast processing of whole arrays
// of vertices (or points, in this case). It saves the call overhead
// associated with the original implementation below and is potentially
// optimized in specific OpenGL implementations.
// Pass a pointer to the start of the point-coordinate array:
glVertexPointer(2, GL_DOUBLE, 0, &xy[0]);
// Enable fast rendering of arrays:
glEnableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) {
if (isdoublecolors) glColorPointer(mc, GL_DOUBLE, 0, colors);
if (isuint8colors) glColorPointer(mc, GL_UNSIGNED_BYTE, 0, bytecolors);
glEnableClientState(GL_COLOR_ARRAY);
}
// Render all n points, starting at point 0, render them as POINTS:
if (nrsize==1) {
// One common point size for all dots provided. Good! This is very efficiently
// done with one single render-call:
glDrawArrays(GL_POINTS, 0, nrpoints);
}
else {
// Different size for each dot provided: We have to do One GL - call per dot.
// This is *pretty inefficient* and should be reimplemented in the future via
// Point-Sprite extensions, cleverly used display lists or via vertex-shaders...
// For now we do it the stupid way:
for (i=0; i<nrpoints; i++) {
if (size[i] > pointsizerange[1] || size[i] < pointsizerange[0]) {
printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n",
size[i], pointsizerange[0], pointsizerange[1]);
PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots').");
}
// Setup point size for this point:
glPointSize(size[i]);
// Render point:
glDrawArrays(GL_POINTS, i, 1);
}
}
// Disable fast rendering of arrays:
glDisableClientState(GL_VERTEX_ARRAY);
if (usecolorvector) glDisableClientState(GL_COLOR_ARRAY);
// Restore old matrix from backup copy, undoing the global translation:
glPopMatrix();
// turn off antialiasing again
if(idot_type) glDisable(GL_POINT_SMOOTH);
// Reset pointsize to 1.0
glPointSize(1);
// Mark end of drawing op. This is needed for single buffered drawing:
PsychFlushGL(windowRecord);
//All psychfunctions require this.
return(PsychError_none);
}
void CloudsVisualSystemCities::generateCube(float sizeX, float sizeY, float sizeZ)
{
ofPushMatrix();
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
if(ofGetStyle().bFill) {
GLfloat vertices[] = {
+sizeX,-sizeY,+sizeZ, +sizeX,-sizeY,-sizeZ, +sizeX,+sizeY,-sizeZ, +sizeX,+sizeY,+sizeZ,
+sizeX,+sizeY,+sizeZ, +sizeX,+sizeY,-sizeZ, -sizeX,+sizeY,-sizeZ, -sizeX,+sizeY,+sizeZ,
+sizeX,+sizeY,+sizeZ, -sizeX,+sizeY,+sizeZ, -sizeX,-sizeY,+sizeZ, +sizeX,-sizeY,+sizeZ,
-sizeX,-sizeY,+sizeZ, -sizeX,+sizeY,+sizeZ, -sizeX,+sizeY,-sizeZ, -sizeX,-sizeY,-sizeZ,
-sizeX,-sizeY,+sizeZ, -sizeX,-sizeY,-sizeZ, +sizeX,-sizeY,-sizeZ, +sizeX,-sizeY,+sizeZ,
-sizeX,-sizeY,-sizeZ, -sizeX,+sizeY,-sizeZ, +sizeX,+sizeY,-sizeZ, +sizeX,-sizeY,-sizeZ
};
glVertexPointer(3, GL_FLOAT, 0, vertices);
static GLfloat normals[] = {
+1,0,0, +1,0,0, +1,0,0, +1,0,0,
0,+1,0, 0,+1,0, 0,+1,0, 0,+1,0,
0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1,
-1,0,0, -1,0,0, -1,0,0, -1,0,0,
0,-1,0, 0,-1,0, 0,-1,0, 0,-1,0,
0,0,+1, 0,0,+1, 0,0,+1, 0,0,+1
};
glNormalPointer(GL_FLOAT, 0, normals);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
static GLfloat tex[] = {
1,0, 0,0, 0,1, 1,1,
1,1, 1,0, 0,0, 0,1,
0,1, 1,1, 1,0, 0,0,
0,0, 0,1, 1,1, 1,0,
0,0, 0,1, 1,1, 1,0,
0,0, 0,1, 1,1, 1,0
};
glTexCoordPointer(2, GL_FLOAT, 0, tex);
GLubyte indices[] = {
0,1,2, // right top left
0,2,3, // right bottom right
4,5,6, // bottom top right
4,6,7, // bottom bottom left
8,9,10, // back bottom right
8,10,11, // back top left
12,13,14, // left bottom right
12,14,15, // left top left
16,17,18, // ... etc
16,18,19,
20,21,22,
20,22,23
};
glDrawElements(GL_TRIANGLES, 3 * 6 * 2, GL_UNSIGNED_BYTE, indices);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
} else {
GLfloat vertices[] = {
+sizeX,+sizeY,+sizeZ,
+sizeX,+sizeY,-sizeZ,
+sizeX,-sizeY,+sizeZ,
+sizeX,-sizeY,-sizeZ,
-sizeX,+sizeY,+sizeZ,
-sizeX,+sizeY,-sizeZ,
-sizeX,-sizeY,+sizeZ,
-sizeX,-sizeY,-sizeZ
};
glVertexPointer(3, GL_FLOAT, 0, vertices);
static float n = sqrtf(3);
static GLfloat normals[] = {
+n,+n,+n,
+n,+n,-n,
+n,-n,+n,
+n,-n,-n,
-n,+n,+n,
-n,+n,-n,
-n,-n,+n,
-n,-n,-n
};
glNormalPointer(GL_FLOAT, 0, normals);
static GLubyte indices[] = {
0,1, 1,3, 3,2, 2,0,
4,5, 5,7, 7,6, 6,4,
0,4, 5,1, 7,3, 6,2
};
glDrawElements(GL_LINES, 4 * 2 * 3, GL_UNSIGNED_BYTE, indices);
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
ofPopMatrix();
}
//-*****************************************************************************
void MeshDrwHelper::draw( const DrawContext & iCtx ) const
{
// Bail if invalid.
if ( !m_valid || m_triangles.size() < 1 || !m_meshP )
{
return;
}
const V3f *points = m_meshP->get();
const V3f *normals = NULL;
if ( m_meshN && ( m_meshN->size() == m_meshP->size() ) )
{
normals = m_meshN->get();
}
else if ( m_customN.size() == m_meshP->size() )
{
normals = &(m_customN.front());
}
#ifndef SIMPLE_ABC_VIEWER_NO_GL_CLIENT_STATE
//#if 0
{
GL_NOISY( glEnableClientState( GL_VERTEX_ARRAY ) );
if ( normals )
{
GL_NOISY( glEnableClientState( GL_NORMAL_ARRAY ) );
GL_NOISY( glNormalPointer( GL_FLOAT, 0,
( const GLvoid * )normals ) );
}
GL_NOISY( glVertexPointer( 3, GL_FLOAT, 0,
( const GLvoid * )points ) );
GL_NOISY( glDrawElements( GL_TRIANGLES,
( GLsizei )m_triangles.size() * 3,
GL_UNSIGNED_INT,
( const GLvoid * )&(m_triangles[0]) ) );
if ( normals )
{
GL_NOISY( glDisableClientState( GL_NORMAL_ARRAY ) );
}
GL_NOISY( glDisableClientState( GL_VERTEX_ARRAY ) );
}
#else
glBegin( GL_TRIANGLES );
for ( size_t i = 0; i < m_triangles.size(); ++i )
{
const Tri &tri = m_triangles[i];
const V3f &vertA = points[tri[0]];
const V3f &vertB = points[tri[1]];
const V3f &vertC = points[tri[2]];
if ( normals )
{
const V3f &normA = normals[tri[0]];
glNormal3fv( ( const GLfloat * )&normA );
glVertex3fv( ( const GLfloat * )&vertA );
const V3f &normB = normals[tri[1]];
glNormal3fv( ( const GLfloat * )&normB );
glVertex3fv( ( const GLfloat * )&vertB );
const V3f &normC = normals[tri[2]];
glNormal3fv( ( const GLfloat * )&normC );
glVertex3fv( ( const GLfloat * )&vertC );
}
else
{
V3f AB = vertB - vertA;
V3f AC = vertC - vertA;
V3f N = AB.cross( AC );
if ( N.length() > 1.0e-4f )
{
N.normalize();
glNormal3fv( ( const GLfloat * )&N );
}
glVertex3fv( ( const GLfloat * )&vertA );
glVertex3fv( ( const GLfloat * )&vertB );
glVertex3fv( ( const GLfloat * )&vertC );
}
}
glEnd();
#endif
}
void RenderCollisionBoxes(void)
{
int i,j;
enemy_t* enemy;
xf_colorless_sprite_t* enemyBullet;
float alpha = 0.3;
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_CULL_FACE);
glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glColor4f(1, 1, 1, alpha);
//PLAYER
for (i=0; i < numPlayers; i++) {
collisionBoxes[1] = players[i].ss_boudaries[UP];
collisionBoxes[0] = players[i].ss_boudaries[LEFT];
collisionBoxes[3] = players[i].ss_boudaries[DOWN];
collisionBoxes[2] = players[i].ss_boudaries[LEFT];
collisionBoxes[5] = players[i].ss_boudaries[DOWN];
collisionBoxes[4] = players[i].ss_boudaries[RIGHT];
collisionBoxes[7] = players[i].ss_boudaries[UP];
collisionBoxes[6] = players[i].ss_boudaries[RIGHT];
glVertexPointer (2, GL_SHORT,0,collisionBoxes);
glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices);
}
//ENEMIES
glColor4f(1, 0, 0, alpha);
enemy = ENE_GetFirstEnemy();
while (enemy != NULL) {
collisionBoxes[1] = enemy->ss_boudaries[UP];
collisionBoxes[0] = enemy->ss_boudaries[LEFT];
collisionBoxes[3] = enemy->ss_boudaries[DOWN];
collisionBoxes[2] = enemy->ss_boudaries[LEFT];
collisionBoxes[5] = enemy->ss_boudaries[DOWN];
collisionBoxes[4] = enemy->ss_boudaries[RIGHT];
collisionBoxes[7] = enemy->ss_boudaries[UP];
collisionBoxes[6] = enemy->ss_boudaries[RIGHT];
glVertexPointer (2, GL_SHORT,0,collisionBoxes);
glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices);
enemy = enemy->next;
}
//PLAYER BULLETS
glColor4f(0, 0, 1, alpha);
for (i=0; i < numPlayers; i++)
{
for (j=0; j < MAX_PLAYER_BULLETS; j++)
{
if (players[i].bullets[j].expirationTime < simulationTime)
continue;
collisionBoxes[1] = players[i].bullets[j].ss_boudaries[UP];
collisionBoxes[0] = players[i].bullets[j].ss_boudaries[LEFT];
collisionBoxes[3] = players[i].bullets[j].ss_boudaries[DOWN];
collisionBoxes[2] = players[i].bullets[j].ss_boudaries[LEFT];
collisionBoxes[5] = players[i].bullets[j].ss_boudaries[DOWN];
collisionBoxes[4] = players[i].bullets[j].ss_boudaries[RIGHT];
collisionBoxes[7] = players[i].bullets[j].ss_boudaries[UP];
collisionBoxes[6] = players[i].bullets[j].ss_boudaries[RIGHT];
glVertexPointer (2, GL_SHORT,0,collisionBoxes);
glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices);
}
}
//ENEMY BULLETS
glColor4f(1, 0, 1, alpha);
enemyBullet = partLib.ss_vertices;
i = 0;
while( i < partLib.numParticules)
{
collisionBoxes[0] = enemyBullet->pos[X];
collisionBoxes[1] = enemyBullet->pos[Y];
collisionBoxes[2] = enemyBullet->pos[X];
collisionBoxes[3] = enemyBullet[1].pos[Y];
collisionBoxes[4] = enemyBullet[2].pos[X];
collisionBoxes[5] = enemyBullet[1].pos[Y];
collisionBoxes[6] = enemyBullet[2].pos[X];
collisionBoxes[7] = enemyBullet->pos[Y];
glVertexPointer (2, GL_SHORT,0,collisionBoxes);
glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, collisionBoxesIndices);
enemyBullet+=4;
i++;
}
//glDisable(GL_BLEND);
glBlendFunc(GL_ALPHA, GL_ONE);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glColor4f(1, 1, 1, 1);
if (light.enabled)
glEnable(GL_LIGHTING);
}
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine:
// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
void ImGui_ImplGlfw_RenderDrawLists(ImDrawData* draw_data)
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
ImGuiIO& io = ImGui::GetIO();
int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
if (fb_width == 0 || fb_height == 0)
return;
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
// We are using the OpenGL fixed pipeline to make the example code simpler to read!
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers.
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnable(GL_TEXTURE_2D);
//glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context
// Setup viewport, orthographic projection matrix
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0.0f, io.DisplaySize.x, io.DisplaySize.y, 0.0f, -1.0f, +1.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
// Render command lists
#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const unsigned char* vtx_buffer = (const unsigned char*)&cmd_list->VtxBuffer.front();
const ImDrawIdx* idx_buffer = &cmd_list->IdxBuffer.front();
glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, pos)));
glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, uv)));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + OFFSETOF(ImDrawVert, col)));
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback)
{
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer);
}
idx_buffer += pcmd->ElemCount;
}
}
#undef OFFSETOF
// Restore modified state
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glPopAttrib();
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
}
void initFixedRenderer(renderer_t* renderer)
{
GLenum err;
//printf("[initFixedRenderer] has a nnnasty hack");
renderer->type = GL_11_RENDERER ;
//renderer->supportBumpMapping = 0;
renderer->props = 0;
renderer->Set3D = Set3DF;
renderer->StopRendition = StopRenditionF;
renderer->SetTexture = SetTextureF;
renderer->RenderEntities = RenderEntitiesF;
renderer->UpLoadTextureToGpu = UpLoadTextureToGPUF;
renderer->UpLoadEntityToGPU = UpLoadEntityToGPUF;
renderer->Set2D = Set2DF;
renderer->RenderPlayersBullets = RenderPlayersBulletsF ;
renderer->RenderString = RenderStringF;
renderer->GetColorBuffer = GetColorBufferF;
renderer->RenderFXSprites = RenderFXSpritesF;
renderer->DrawControls = DrawControlsF;
renderer->FreeGPUTexture = FreeGPUTextureF;
renderer->FreeGPUBuffer = FreeGPUBufferF;
renderer->UploadVerticesToGPU = UploadVerticesToGPUF;
renderer->StartCleanFrame = StartCleanFrameF;
renderer->RenderColorlessSprites = RenderColorlessSpritesF;
renderer->FadeScreen = FadeScreenF;
renderer->SetMaterialTextureBlending = SetMaterialTextureBlendingF;
renderer->SetTransparency = SetTransparencyF;
glViewport(renderer->viewPortDimensions[VP_X],
renderer->viewPortDimensions[VP_Y],
renderer->viewPortDimensions[VP_WIDTH],
renderer->viewPortDimensions[VP_HEIGHT]);
glEnable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glClearColor(0, 0, 0,1.0f);
glColor4f(1.0f, 1.0f, 1.0f,1.0f);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(textureMatrix);
err = glGetError();
if (err != GL_NO_ERROR)
printf("Error initing 1.1: glError: 0x%04X", err);
}
void deferred_renderer_render_animated(animated_object* ao) {
if (ao->skeleton->num_bones > MAX_BONES) {
error("animated object skeleton has too many bones (over %i)", MAX_BONES);
}
matrix_4x4 r_world_matrix = m44_world( ao->position, ao->scale, ao->rotation );
m44_to_array(r_world_matrix, WORLD_MATRIX);
skeleton_gen_transforms(ao->pose);
for(int i = 0; i < ao->skeleton->num_bones; i++) {
matrix_4x4 base, ani;
base = ao->skeleton->inv_transforms[i];
ani = ao->pose->transforms[i];
bone_matrices[i] = m44_mul_m44(ani, base);
m44_to_array(bone_matrices[i], bone_matrix_data + (i * 4 * 4));
}
renderable* r = ao->renderable;
for(int i = 0; i < r->num_surfaces; i++) {
renderable_surface* s = r->surfaces[i];
if(s->is_rigged) {
GLuint program_animated_handle = shader_program_handle(PROGRAM_ANIMATED);
glUseProgram(program_animated_handle);
deferred_renderer_use_material(s->base, PROGRAM_ANIMATED);
GLint bone_world_matrices_u = glGetUniformLocation(program_animated_handle, "bone_world_matrices");
glUniformMatrix4fv(bone_world_matrices_u, ao->skeleton->num_bones, GL_FALSE, bone_matrix_data);
GLint bone_count_u = glGetUniformLocation(program_animated_handle, "bone_count");
glUniform1i(bone_count_u, ao->skeleton->num_bones);
GLsizei stride = sizeof(float) * 24;
glBindBuffer(GL_ARRAY_BUFFER, s->vertex_vbo);
glVertexPointer(3, GL_FLOAT, stride, (void*)0);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexAttribPointer(NORMAL, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 3));
glEnableVertexAttribArray(NORMAL);
glVertexAttribPointer(TANGENT, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 6));
glEnableVertexAttribArray(TANGENT);
glVertexAttribPointer(BINORMAL, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 9));
glEnableVertexAttribArray(BINORMAL);
glTexCoordPointer(2, GL_FLOAT, stride, (void*)(sizeof(float) * 12));
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexAttribPointer(BONE_INDICIES, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 18));
glEnableVertexAttribArray(BONE_INDICIES);
glVertexAttribPointer(BONE_WEIGHTS, 3, GL_FLOAT, GL_FALSE, stride, (void*)(sizeof(float) * 21));
glEnableVertexAttribArray(BONE_WEIGHTS);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->triangle_vbo);
glDrawElements(GL_TRIANGLES, s->num_triangles * 3, GL_UNSIGNED_INT, (void*)0);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableVertexAttribArray(NORMAL);
glDisableVertexAttribArray(TANGENT);
glDisableVertexAttribArray(BINORMAL);
glDisableVertexAttribArray(BONE_INDICIES);
glDisableVertexAttribArray(BONE_WEIGHTS);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glUseProgram(0);
} else {
error("Animated object is not rigged!");
}
}
}
void CCharShape::DrawShadowSphere (TMatrix mat) {
double theta, phi, d_theta, d_phi, eps, twopi;
double x, y, z;
int div = param.tux_shadow_sphere_divisions;
TVector3 pt, nml;
eps = 1e-15;
twopi = M_PI * 2.0;
d_theta = d_phi = M_PI / div;
GLfloat* vtx = (GLfloat*) alloca(3*2*(div+4)*sizeof(GLfloat));
GLfloat* nrm = (GLfloat*) alloca(3*2*(div+4)*sizeof(GLfloat));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vtx);
glNormalPointer(GL_FLOAT, 0, nrm);
for (phi = 0.0; phi + eps < M_PI; phi += d_phi) {
double cos_theta, sin_theta;
double sin_phi, cos_phi;
double sin_phi_d_phi, cos_phi_d_phi;
int num_vertices = 0;
GLfloat *pvtx = vtx;
GLfloat *pnrm = nrm;
sin_phi = sin (phi);
cos_phi = cos (phi);
sin_phi_d_phi = sin (phi + d_phi);
cos_phi_d_phi = cos (phi + d_phi);
if (phi <= eps) {
BuildShadowVertex (0., 0., 1., mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
for (theta = 0.0; theta + eps < twopi; theta += d_theta) {
sin_theta = sin (theta);
cos_theta = cos (theta);
x = cos_theta * sin_phi_d_phi;
y = sin_theta * sin_phi_d_phi;
z = cos_phi_d_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
}
x = sin_phi_d_phi;
y = 0.0;
z = cos_phi_d_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices);
} else if (phi + d_phi + eps >= M_PI) {
BuildShadowVertex (0., 0., -1., mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
for (theta = twopi; theta - eps > 0; theta -= d_theta) {
sin_theta = sin (theta);
cos_theta = cos (theta);
x = cos_theta * sin_phi;
y = sin_theta * sin_phi;
z = cos_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
}
x = sin_phi;
y = 0.0;
z = cos_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices);
} else {
for (theta = 0.0; theta + eps < twopi; theta += d_theta) {
sin_theta = sin (theta);
cos_theta = cos (theta);
x = cos_theta * sin_phi;
y = sin_theta * sin_phi;
z = cos_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
x = cos_theta * sin_phi_d_phi;
y = sin_theta * sin_phi_d_phi;
z = cos_phi_d_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
}
x = sin_phi;
y = 0.0;
z = cos_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
x = sin_phi_d_phi;
y = 0.0;
z = cos_phi_d_phi;
BuildShadowVertex (x, y, z, mat, &pt, &nml);
*pnrm++ = nml.x; *pnrm++ = nml.y; *pnrm++ = nml.z;
*pvtx++ = pt.x; *pvtx++ = pt.y; *pvtx++ = pt.z;
num_vertices++;
glDrawArrays(GL_TRIANGLE_STRIP, 0, num_vertices);
}
}
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
static void va_render (void)
{
GLint i;
for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++) {
struct ATTRIB_DATA *att = &attribs[i];
switch (att->dispatch)
{
case C:
glColorPointer (4, GL_FLOAT, 0, att->data);
glEnableClientState (GL_COLOR_ARRAY);
break;
case S:
glSecondaryColorPointerEXT (4, GL_FLOAT, 0, att->data);
glEnableClientState (GL_SECONDARY_COLOR_ARRAY_EXT);
break;
case N:
glNormalPointer (GL_FLOAT, 0, att->data);
glEnableClientState (GL_NORMAL_ARRAY);
break;
case V:
glVertexPointer (4, GL_FLOAT, 0, att->data);
glEnableClientState (GL_VERTEX_ARRAY);
break;
case T:
assert (att->index >= 0 && att->index < 8);
glClientActiveTextureARB (GL_TEXTURE0_ARB + att->index);
glTexCoordPointer (4, GL_FLOAT, 0, att->data);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
break;
case F:
glFogCoordPointerEXT (GL_FLOAT, 0, att->data);
glEnableClientState (GL_FOG_COORDINATE_ARRAY_EXT);
break;
case A:
assert (att->index > 0 && att->index < 16);
glVertexAttribPointerARB (att->index, 4, GL_FLOAT, GL_FALSE, 0, att->data);
glEnableVertexAttribArrayARB (att->index);
break;
default:
assert (0);
}
}
glDrawArrays (GL_POINTS, 0, 1);
for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++) {
struct ATTRIB_DATA *att = &attribs[i];
switch (att->dispatch)
{
case C:
glDisableClientState (GL_COLOR_ARRAY);
break;
case S:
glDisableClientState (GL_SECONDARY_COLOR_ARRAY_EXT);
break;
case N:
glDisableClientState (GL_NORMAL_ARRAY);
break;
case V:
glDisableClientState (GL_VERTEX_ARRAY);
break;
case T:
glClientActiveTextureARB (GL_TEXTURE0_ARB + att->index);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
break;
case F:
glDisableClientState (GL_FOG_COORDINATE_ARRAY_EXT);
break;
case A:
glDisableVertexAttribArrayARB (att->index);
break;
default:
assert (0);
}
}
}
void FGAPIENTRY
glutSolidTorusx(GLfixed ir, GLfixed or, GLint sides, GLint rings)
{
GLint i, j, k, triangles;
float s, t, x, y, z, twopi, nx, ny, nz;
float sin_s, cos_s, cos_t, sin_t, twopi_s, twopi_t;
float twopi_sides, twopi_rings;
static GLfixed* v, *n;
static GLfixed parms[4];
float irf, orf;
GLfixed *p, *q;
if (v)
{
if (parms[0] != ir || parms[1] != or || parms[2] != sides || parms[3] != rings)
{
free(v);
free(n);
n = v = 0;
glVertexPointer(3, GL_FIXED, 0, 0);
glNormalPointer(GL_FIXED, 0, 0);
}
}
if (!v)
{
irf = _FIXED2FLOAT(ir);
orf = _FIXED2FLOAT(or);
parms[0] = ir;
parms[1] = or;
parms[2] = (GLfixed)sides;
parms[3] = (GLfixed)rings;
p = v = (GLfixed*)malloc(sides*(rings+1)*2*3*sizeof *v);
q = n = (GLfixed*)malloc(sides*(rings+1)*2*3*sizeof *n);
twopi = 2.0f * (float)PI_;
twopi_sides = twopi / sides;
twopi_rings = twopi / rings;
for (i = 0; i < sides; i++)
{
for (j = 0; j <= rings; j++)
{
for (k = 1; k >= 0; k--)
{
s = (i + k) % sides + 0.5f;
t = (float)( j % rings);
twopi_s = s * twopi_sides;
twopi_t = t * twopi_rings;
cos_s = (float)cos(twopi_s);
sin_s = (float)sin(twopi_s);
cos_t = (float)cos(twopi_t);
sin_t = (float)sin(twopi_t);
x = (orf + irf * cos_s) * cos_t;
y = (orf + irf * cos_s) * sin_t;
z = irf * sin_s;
*p++ = _FLOAT2FIXED(x);
*p++ = _FLOAT2FIXED(y);
*p++ = _FLOAT2FIXED(z);
nx = cos_s * cos_t;
ny = cos_s * sin_t;
nz = sin_s;
*q++ = _FLOAT2FIXED(nx);
*q++ = _FLOAT2FIXED(ny);
*q++ = _FLOAT2FIXED(nz);
}
}
}
}
glVertexPointer(3, GL_FIXED, 0, v);
glNormalPointer(GL_FIXED, 0, n);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
triangles = (rings + 1) * 2;
for(i = 0; i < sides; i++)
glDrawArrays(GL_TRIANGLE_STRIP, triangles * i, triangles);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void ofApp::drawScene(int iCameraDraw){
nodeSwarm.draw();
nodeGrid.draw();
//////////////////////////////////
// DRAW EASYCAM FRUSTUM PREVIEW
//////////////////////////////////
//
// This code draws our camera in
// the scene (reddy/pink lines)
//
// The pyramid-like shape defined
// by the cameras view is called
// a 'frustum'.
//
// Often we refer to the volume
// which can be seen by the
// camera as 'the view frustum'.
//
//let's not draw the camera
//if we're looking through it
if (iCameraDraw != 0)
{
ofPushStyle();
//in 'camera space' this frustum
//is defined by a box with bounds
//-1->1 in each axis
//
//to convert from camera to world
//space, we multiply by the inverse
//matrix of the camera
//
//by applying this transformation
//our box in camera space is
//transformed into a frustum in
//world space.
ofMatrix4x4 inverseCameraMatrix;
//the camera's matricies are dependant on
//the aspect ratio of the viewport
//so we must send the viewport if it's not
//the same as fullscreen
//
//watch the aspect ratio of preview camera
inverseCameraMatrix.makeInvertOf(camEasyCam.getModelViewProjectionMatrix( (iMainCamera == 0 ? viewMain : viewGrid[0]) ));
// By default, we can say
// 'we are drawing in world space'
//
// The camera matrix performs
// world->camera
//
// The inverse camera matrix performs
// camera->world
//
// Our box is in camera space, if we
// want to draw that into world space
// we have to apply the camera->world
// transformation.
//
ofPushMatrix();
glMultMatrixf(inverseCameraMatrix.getPtr());
ofSetColor(255, 100, 100);
//////////////////////
// DRAW WIREFRAME BOX
//
// xy plane at z=-1 in camera sapce
// (small rectangle at camera position)
//
GLfloat vertices1[] = {
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f
};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices1);
glDrawArrays(GL_LINE_LOOP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
// xy plane at z=1 in camera space
// (generally invisible because so far away)
//
GLfloat vertices2[] = {
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices2);
glDrawArrays(GL_LINE_LOOP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
// connecting lines between above 2 planes
// (these are the long lines)
//
GLfloat vertices3[] = {
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f
};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertices3);
glDrawArrays(GL_LINE_LOOP, 0, 8);
glDisableClientState(GL_VERTEX_ARRAY);
//
//////////////////////
ofPopStyle();
ofPopMatrix();
}
//
//////////////////////////////////
//////////////////////////////////
// DRAW RAY
//////////////////////////////////
//
//draw if we've got camEasyCam selected
//and we're not looking through it
if (iMainCamera == 0 && iCameraDraw != 0)
{
ofPushStyle();
ofSetColor(100, 100, 255);
ofDrawLine(ray[0], ray[1]);
ofPopStyle();
}
//
//////////////////////////////////
}
void FGAPIENTRY
glutWireCubex(GLfixed size)
{
static GLfixed v[72];
static const int cubev[72] = // 72 = 3*6*4
{
-1, -1, 1, /* front */
1, -1, 1,
1, 1, 1,
-1, 1, 1,
-1, 1, -1, /* back */
1, 1, -1,
1, -1, -1,
-1, -1, -1,
-1, -1, -1, /* left */
-1, -1, 1,
-1, 1, 1,
-1, 1, -1,
1, -1, 1, /* right */
1, -1, -1,
1, 1, -1,
1, 1, 1,
-1, 1, 1, /* top */
1, 1, 1,
1, 1, -1,
-1, 1, -1,
-1, -1, -1, /* bottom */
1, -1, -1,
1, -1, 1,
-1, -1, 1,
};
static const float cuben[72] =
{
0, 0, F1, /* front */
0, 0, F1,
0, 0, F1,
0, 0, F1,
0, 0, FM1, /* back */
0, 0, FM1,
0, 0, FM1,
0, 0, FM1,
FM1, 0, 0, /* left */
FM1, 0, 0,
FM1, 0, 0,
FM1, 0, 0,
F1, 0, 0, /* right */
F1, 0, 0,
F1, 0, 0,
F1, 0, 0,
0, F1, 0, /* top */
0, F1, 0,
0, F1, 0,
0, F1, 0,
0, FM1, 0, /* bottom */
0, FM1, 0,
0, FM1, 0,
0, FM1, 0,
};
int i;
size /= 2;
for(i = 0; i < 72; i++)
v[i] = cubev[i] * size;
glVertexPointer(3, GL_FIXED, 0, v);
glNormalPointer(GL_FIXED, 0, cuben);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
for(i = 0; i < 6; i++)
glDrawArrays(GL_LINE_LOOP, 4*i, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void render_scene()
{
/* material properties for objects in scene */
static GLfloat wall_mat[4]={1.0f, 1.0f, 1.0f, 1.0f};
static GLfloat disk_mat[4]={0.5f, 0.5f, 1.0f, 1.0f};
GLfloat texcoords[4][2];
GLfloat vertices[4][3];
glShadeModel(GL_SMOOTH);
glVertexPointer(3, GL_FLOAT, 0, vertices);
glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
/* Enable vertices and texcoords arrays */
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glGetError();
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
/* Note: wall verticies are ordered so they are all front facing this lets
me do back face culling to speed things up. */
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, wall_mat);
/* floor */
glEnable(GL_TEXTURE_2D);
glNormal3f(0.f, 1.f, 0.f);
/* Fill texture coordinates and vertices arrays */
texcoords[0][0]=0;
texcoords[0][1]=0;
vertices[0][0]=-100.f;
vertices[0][1]=-100.f;
vertices[0][2]=-320.f;
texcoords[1][0]=1;
texcoords[1][1]=0;
vertices[1][0]=100.f;
vertices[1][1]=-100.f;
vertices[1][2]=-320.f;
texcoords[3][0]=1;
texcoords[3][1]=1;
vertices[3][0]=100.f;
vertices[3][1]=-100.f;
vertices[3][2]=-520.f;
texcoords[2][0]=0;
texcoords[2][1]=1;
vertices[2][0]=-100.f;
vertices[2][1]=-100.f;
vertices[2][2]=-520.f;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
/* walls */
glEnableClientState(GL_VERTEX_ARRAY);
glNormal3f(1.f, 0.f, 0.f);
vertices[0][0]=-100.f;
vertices[0][1]=-100.f;
vertices[0][2]=-320.f;
vertices[1][0]=-100.f;
vertices[1][1]=-100.f;
vertices[1][2]=-520.f;
vertices[3][0]=-100.f;
vertices[3][1]=100.f;
vertices[3][2]=-520.f;
vertices[2][0]=-100.f;
vertices[2][1]=100.f;
vertices[2][2]=-320.f;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glNormal3f(-1.f, 0.f, 0.f);
vertices[0][0]=100.f;
vertices[0][1]=-100.f;
vertices[0][2]=-320.f;
vertices[1][0]=100.f;
vertices[1][1]=100.f;
vertices[1][2]=-320.f;
vertices[3][0]=100.f;
vertices[3][1]=100.f;
vertices[3][2]=-520.f;
vertices[2][0]=100.f;
vertices[2][1]=-100.f;
vertices[2][2]=-520.f;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glNormal3f(0.f, -1.f, 0.f);
vertices[0][0]=-100.f;
vertices[0][1]=100.f;
vertices[0][2]=-320.f;
vertices[1][0]=-100.f;
vertices[1][1]=100.f;
vertices[1][2]=-520.f;
vertices[3][0]=100.f;
vertices[3][1]=100.f;
vertices[3][2]=-520.f;
vertices[2][0]=100.f;
vertices[2][1]=100.f;
vertices[2][2]=-320.f;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glNormal3f(0.f, 0.f, 1.f);
vertices[0][0]=-100.f;
vertices[0][1]=-100.f;
vertices[0][2]=-520.f;
vertices[1][0]=100.f;
vertices[1][1]=-100.f;
vertices[1][2]=-520.f;
vertices[3][0]=100.f;
vertices[3][1]=100.f;
vertices[3][2]=-520.f;
vertices[2][0]=-100.f;
vertices[2][1]=100.f;
vertices[2][2]=-520.f;
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
/* Draw disk */
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, disk_mat);
glPushMatrix();
glTranslatef(-50.f, 0.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_fill, 5.0f, 24.0f, 30, 1);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0f, 0.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_point, 5.0f, 24.0f, 60, 5);
glPopMatrix();
glPushMatrix();
glTranslatef(50.f, 0.f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_line, 5.0f, 24.0f, 40, 5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0f, 50.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_silh, 5.0f, 24.0f, 40, 5);
glPopMatrix();
/* Draw flat shaded disk */
glShadeModel(GL_FLAT);
glPushMatrix();
glTranslatef(-50.f, 50.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_fill_flat, 5.0f, 24.0f, 30, 1);
glPopMatrix();
/* Draw textured disk */
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glPushMatrix();
glTranslatef(-50.f, -50.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_fill_texture, 5.0f, 24.0f, 30, 1);
glPopMatrix();
glPushMatrix();
glTranslatef(0.f, -50.0f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
glRotatef(rotate, 1.f, 0.0f, 0.0f);
gluDisk(disk_fill_texture, 0.0f, 24.0f, 30, 1);
glPopMatrix();
rotate+=1.0f;
if (glGetError())
{
printf("Oops! I screwed up my OpenGL ES calls somewhere\n");
}
}
void drawGLScene(AndroidContext *rc)
{
#ifdef DROID_EXTREME_LOGS
LOG( ANDROID_LOG_VERBOSE, TAG, "drawGLScene : start");
#endif /* DROID_EXTREME_LOGS */
GLfloat vertices[4][3];
GLfloat texcoord[4][2];
// int i, j;
float rgba[4];
#ifdef GLES_FRAMEBUFFER_TEST
glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
#endif
// Reset states
rgba[0] = rgba[1] = rgba[2] = 0.f;
rgba[0] = 1.f;
glColor4f(1.f, 1.f, 1.f, 1.f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, rgba);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, rgba);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, rgba);
glDisable(GL_CULL_FACE | GL_NORMALIZE | GL_LIGHTING | GL_BLEND | GL_FOG | GL_COLOR_MATERIAL | GL_TEXTURE_2D);
/* Clear The Screen And The Depth Buffer */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glBindTexture( GL_TEXTURE_2D, rc->texID);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// for ( i = 0; i < rc->height/2; i++ )
// for ( j = 0; j < rc->width; j++ )
// rc->texData[ i*rc->width*NBPP + j*NBPP + 3] = 200;
// memset(rc->texData, 255, 4 * rc->width * rc->height );
#ifndef GLES_FRAMEBUFFER_TEST
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, rc->tex_width, rc->tex_height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, rc->texData );
#endif
if ( rc->draw_texture )
{
int cropRect[4] = {0,rc->height,rc->width,-rc->height};
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect);
glDrawTexsOES(0, 0, 0, rc->width, rc->height);
}
else
{
/* Enable VERTEX array */
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
/* Setup pointer to VERTEX array */
glVertexPointer(3, GL_FLOAT, 0, vertices);
glTexCoordPointer(2, GL_FLOAT, 0, texcoord);
/* Move Left 1.5 Units And Into The Screen 6.0 */
glLoadIdentity();
//glTranslatef(0.0f, 0.0f, -3.3f);
//glTranslatef(0.0f, 0.0f, -2.3f);
/* Top Right Of The Quad */
vertices[0][0]=rc->tex_width; vertices[0][1]=rc->tex_height; vertices[0][2]=0.0f;
texcoord[0][0]=1.f; texcoord[0][1]=0.f;
/* Top Left Of The Quad */
vertices[1][0]=0.f; vertices[1][1]=rc->tex_height; vertices[1][2]=0.0f;
texcoord[1][0]=0.f; texcoord[1][1]=0.f;
/* Bottom Left Of The Quad */
vertices[2][0]=rc->tex_width; vertices[2][1]=0.f; vertices[2][2]=0.0f;
texcoord[2][0]=1.f; texcoord[2][1]=1.f;
/* Bottom Right Of The Quad */
vertices[3][0]=0.f; vertices[3][1]=0.f; vertices[3][2]=0.0f;
texcoord[3][0]=0.f; texcoord[3][1]=1.f;
/* Drawing using triangle strips, draw triangles using 4 vertices */
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
/* Disable vertex array */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glDisable(GL_TEXTURE_2D);
/* Flush all drawings */
glFinish();
#ifdef GLES_FRAMEBUFFER_TEST
glBindFramebufferOES(GL_FRAMEBUFFER_OES, rc->framebuff);
#endif
#ifdef DROID_EXTREME_LOGS
LOG( ANDROID_LOG_VERBOSE, TAG, "drawGLScene : end");
#endif /* DROID_EXTREME_LOGS */
}
void
__glXDisp_DrawArrays(GLbyte * pc)
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;
GLint numVertexes = hdr->numVertexes;
GLint numComponents = hdr->numComponents;
GLenum primType = hdr->primType;
GLint stride = 0;
int i;
pc += sizeof(__GLXdispatchDrawArraysHeader);
compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
/* compute stride (same for all component arrays) */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
/* set up component arrays */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
switch (component) {
case GL_VERTEX_ARRAY:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(numVals, datatype, stride, pc);
break;
case GL_NORMAL_ARRAY:
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(datatype, stride, pc);
break;
case GL_COLOR_ARRAY:
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(numVals, datatype, stride, pc);
break;
case GL_INDEX_ARRAY:
glEnableClientState(GL_INDEX_ARRAY);
glIndexPointer(datatype, stride, pc);
break;
case GL_TEXTURE_COORD_ARRAY:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(numVals, datatype, stride, pc);
break;
case GL_EDGE_FLAG_ARRAY:
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(stride, (const GLboolean *) pc);
break;
case GL_SECONDARY_COLOR_ARRAY:
{
PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
__glGetProcAddress("glSecondaryColorPointerEXT");
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
SecondaryColorPointerEXT(numVals, datatype, stride, pc);
break;
}
case GL_FOG_COORD_ARRAY:
{
PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
__glGetProcAddress("glFogCoordPointerEXT");
glEnableClientState(GL_FOG_COORD_ARRAY);
FogCoordPointerEXT(datatype, stride, pc);
break;
}
default:
break;
}
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
glDrawArrays(primType, 0, numVertexes);
/* turn off anything we might have turned on */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
glDisableClientState(GL_FOG_COORD_ARRAY);
}
bool Object::draw()
{
if(!alive)
{
return false;
}
if(!visible)
{
return true;
}
if( this->alphaColor < 255)
{
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
//Nouveau Repere
glPushMatrix();
//scaling / Translation / rotations de l'objet
glTranslated(transX,transY,transZ);
glRotated(rotateX,1,0,0);
glRotated(rotateY,0,1,0);
glRotated(rotateZ,0,0,1);
glScalef( xScale, yScale, zScale );
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.0f);
//La couleur Ambiante de l'objet est mise au BLANC ( sinon vert par defaut)
glColor4ub(255,255,255,this->alphaColor);
//Texture a appliquer
glBindTexture(GL_TEXTURE_2D,this->noTexture);
//donne le tableau des points
glVertexPointer( 3, GL_FLOAT, 0, this->data->point );
//on prepare le traçage des points
glEnableClientState( GL_VERTEX_ARRAY );
//donne le tableau des textures
glTexCoordPointer(2, GL_FLOAT, 0, this->data->texture);
//Prepare la pose de la texture
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawElements( GL_TRIANGLES, this->data->nbIndice , GL_UNSIGNED_INT, data->indice );
//on arrete le traçage
glDisableClientState( GL_VERTEX_ARRAY );
//on arrete le traçage de texture
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_ALPHA_TEST);
//Nouveau Repere detruit
glPopMatrix();
return true;
}
void GLWall::RenderWall(int textured)
{
gl_RenderState.Apply();
gl_RenderState.ApplyLightIndex(dynlightindex);
#ifdef NO_VBO
bool nosplit = !!(textured&RWF_NOSPLIT);
bool split = (gl_seamless && !nosplit && seg->sidedef != NULL && !(seg->sidedef->Flags & WALLF_POLYOBJ) && !(flags & GLWF_NOSPLIT));
#if 1 // A bit quicker due to batching, still not very fast..
glBegin(GL_TRIANGLE_FAN);
// lower left corner
if (textured&1) glTexCoord2f(tcs[0].u,tcs[0].v);
glVertex3f(glseg.x1,zbottom[0],glseg.y1);
//if (split && glseg.fracleft==0) SplitLeftEdge(tcs);
// upper left corner
if (textured&1) glTexCoord2f(tcs[1].u,tcs[1].v);
glVertex3f(glseg.x1,ztop[0],glseg.y1);
//if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(tcs);
// color for right side
//if (color2) glColor4fv(color2);
// upper right corner
if (textured&1) glTexCoord2f(tcs[2].u,tcs[2].v);
glVertex3f(glseg.x2,ztop[1],glseg.y2);
//if (split && glseg.fracright==1) SplitRightEdge(tcs);
// lower right corner
if (textured&1) glTexCoord2f(tcs[3].u,tcs[3].v);
glVertex3f(glseg.x2,zbottom[1],glseg.y2);
//if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(tcs);
glEnd();
vertexcount+=4;
#else
static FFlatVertex vtx[100]; // Yes this is static. It's only used once, and I think it's faster as the address doesn't keep changing
FFlatVertex *ptr = &vtx[0];
ptr->Set(glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v);
ptr++;
if (split && glseg.fracleft == 0) SplitLeftEdge(ptr);
ptr->Set(glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v);
ptr++;
if (split && !(flags & GLWF_NOSPLITUPPER)) SplitUpperEdge(ptr);
ptr->Set(glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v);
ptr++;
if (split && glseg.fracright == 1) SplitRightEdge(ptr);
ptr->Set(glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v);
ptr++;
if (split && !(flags & GLWF_NOSPLITLOWER)) SplitLowerEdge(ptr);
// We can workout how many from the difference in pointers
vertcount = (ptr - &vtx[0]);
glTexCoordPointer(2,GL_FLOAT, sizeof(FFlatVertex),&vtx[0].u);
glVertexPointer (3,GL_FLOAT, sizeof(FFlatVertex),&vtx[0].x);
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState (GL_COLOR_ARRAY);
glBindBuffer (GL_ARRAY_BUFFER, 0); // NO VBO
glDrawArrays (GL_TRIANGLE_FAN, 0, vertcount);
vertexcount += vertcount;
#endif
#else
if (gl.buffermethod != BM_DEFERRED)
{
MakeVertices(!!(textured&RWF_NOSPLIT));
}
else if (vertcount == 0)
{
// This should never happen but in case it actually does, use the quad drawer as fallback (without edge splitting.)
// This way it at least gets drawn.
FQuadDrawer qd;
qd.Set(0, glseg.x1, zbottom[0], glseg.y1, tcs[LOLFT].u, tcs[LOLFT].v);
qd.Set(1, glseg.x1, ztop[0], glseg.y1, tcs[UPLFT].u, tcs[UPLFT].v);
qd.Set(2, glseg.x2, ztop[1], glseg.y2, tcs[UPRGT].u, tcs[UPRGT].v);
qd.Set(3, glseg.x2, zbottom[1], glseg.y2, tcs[LORGT].u, tcs[LORGT].v);
qd.Render(GL_TRIANGLE_FAN);
vertexcount += 4;
return;
}
GLRenderer->mVBO->RenderArray(GL_TRIANGLE_FAN, vertindex, vertcount);
vertexcount += vertcount;
#endif
}
