// start rendering to texture
// pass -1 as texture ID to restore default render target
static int setRenderTarget(struct SaslGraphicsCallbacks *canvas,
int textureId)
{
OglCanvas *c = (OglCanvas*)canvas;
assert(canvas);
dumpBuffers(c);
if (! c->fboAvailable) {
printf("fbo not available\n");
return -1;
}
if (-1 != textureId) {
// save state
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
GLint w, h;
glBindTexture(GL_TEXTURE_2D, textureId);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
// enable fbo
c->defaultFbo = getCurrentFbo();
GLuint fbo = getFbo(c, textureId);
if ((GLuint)-1 == fbo) {
printf("can't create fbo\n");
return -1;
}
c->currentFboTex = textureId;
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, textureId, 0);
prepareFbo(c, textureId, w, h);
} else {
// restore default fbo
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, c->defaultFbo);
glBindTexture(GL_TEXTURE_2D, c->currentFboTex);
glGenerateMipmap(GL_TEXTURE);
glBindTexture(GL_TEXTURE_2D, 0);
// restore x-plane state
glPopClientAttrib();
glPopAttrib();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
if (c->currentTexture)
glBindTexture(GL_TEXTURE_2D, c->currentTexture);
c->transform.pop_back();
}
return 0;
}
void Sketcher::renderSelection(QGLShaderProgram *shader, Selection *selection)
{
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
selection->getSelectionMask()->bind();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glViewport(0, 0, selection->getSelectionMask()->size().width(), selection->getSelectionMask()->size().height());
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, +1.0, -1.0, +1.0, -1.0, +1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearColor(0.0, 1.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
shader->bind();
shader->setUniformValue("texture", textureIndex);
//glActiveTexture(GL_TEXTURE3);
this->createSelectionTexture(selection);
//glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glEnable(GL_COLOR_MATERIAL);
glEnable(GL_COLOR_MATERIAL);
glColor4f(1.0, 0.0, 1.0, 1.0);
glBegin(GL_QUADS);
glVertex2f( 1.0, -1.0);
glVertex2f(-1.0, -1.0);
glVertex2f(-1.0, 1.0);
glVertex2f( 1.0, 1.0);
glEnd();
glEnable(GL_COLOR_MATERIAL);
shader->release();
selection->getSelectionMask()->release();
/*QImage p = selection->getSelectionMask()->toImage();
p.save("c:/users/mindek/documents/a.png");*/
selection->setRendered();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPopClientAttrib();
glPopAttrib();
emit selectionRendered();
}
display::scoped_state::~scoped_state()
{
glPopClientAttrib();
glPopAttrib();
} // display::scoped_state::~scoped_state()
void jit_gl_hap_submit_texture(t_jit_gl_hap *x)
{
GLenum type;
GLvoid *baseAddress = CVPixelBufferGetBaseAddress(x->buffer);
glPushAttrib(GL_ENABLE_BIT | GL_TEXTURE_BIT);
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
// Create a new texture if our current one isn't adequate
if (
!x->texture ||
(x->roundedWidth > x->backingWidth) ||
(x->roundedHeight > x->backingHeight) ||
(x->newInternalFormat != x->internalFormat)
) {
glEnable(x->target);
if (x->texture != 0) {
glDeleteTextures(1, &x->texture);
}
glGenTextures(1, &x->texture);
glBindTexture(x->target, x->texture);
x->deletetex = 1;
// On NVIDIA hardware there is a massive slowdown if DXT textures aren't POT-dimensioned, so we use POT-dimensioned backing
x->backingWidth = 1;
while (x->backingWidth < x->roundedWidth) x->backingWidth <<= 1;
x->backingHeight = 1;
while (x->backingHeight < x->roundedHeight) x->backingHeight <<= 1;
glTexParameteri(x->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(x->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(x->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(x->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#ifdef MAC_VERSION
glTexParameteri(x->target, GL_TEXTURE_STORAGE_HINT_APPLE , GL_STORAGE_SHARED_APPLE);
type = GL_UNSIGNED_INT_8_8_8_8_REV;
#else
type = GL_UNSIGNED_BYTE;
#endif
// We allocate the texture with no pixel data, then use CompressedTexSubImage to update the content region
glTexImage2D(x->target, 0, x->newInternalFormat, x->backingWidth, x->backingHeight, 0, GL_BGRA, type, NULL);
x->internalFormat = x->newInternalFormat;
}
else {
glBindTexture(x->target, x->texture);
}
#ifdef MAC_VERSION
glTextureRangeAPPLE(GL_TEXTURE_2D, x->newDataLength, baseAddress);
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
#else
// not sure what this should be, so leaving as default for now
// glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#endif
glCompressedTexSubImage2D(GL_TEXTURE_2D,
0,
0,
0,
x->roundedWidth,
x->roundedHeight,
x->newInternalFormat,
x->newDataLength,
baseAddress);
glPopClientAttrib();
glPopAttrib();
}
t_jit_err jit_gl_hap_draw(t_jit_gl_hap *x)
{
t_jit_err result = JIT_ERR_NONE;
t_jit_gl_drawinfo drawinfo;
if(x->newfile) {
if(x->texture && x->deletetex) {
glDeleteTextures(1, &x->texture);
x->deletetex = 0;
}
x->texture = 0;
jit_gl_hap_load_file(x);
}
if(!x->movieloaded)
return JIT_ERR_NONE;
if(jit_gl_drawinfo_setup(x,&drawinfo))
return JIT_ERR_GENERIC;
jit_gl_hap_getcurrentframe(x);
if(x->validframe) {
GLint previousFBO; // make sure we pop out to the right FBO
#ifdef MAC_VERSION
GLint previousReadFBO;
GLint previousDrawFBO;
#endif
// We are going to bind our FBO to our internal jit.gl.texture as COLOR_0 attachment
// We need the ID, width/height.
GLuint texid = jit_attr_getlong(x->texoutput,ps_glid);
GLuint width = jit_attr_getlong(x->texoutput,ps_width);
GLuint height = jit_attr_getlong(x->texoutput,ps_height);
glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &previousFBO);
#ifdef MAC_VERSION
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &previousReadFBO);
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &previousDrawFBO);
#endif
if(width!=x->dim[0] || height!=x->dim[1]) {
width = x->dim[0];
height = x->dim[1];
jit_attr_setlong_array(x->texoutput, gensym("dim"), 2, x->dim);
jit_attr_user_touch(x, gensym("dim"));
}
if(x->drawhap) {
jit_gl_hap_submit_texture(x);
jit_gl_report_error("jit.gl.hap submit texture");
}
if(jit_gl_hap_draw_begin(x, texid, width, height)) {
jit_gl_report_error("jit.gl.hap draw begin");
jit_gl_hap_dodraw(x, width, height);
jit_gl_report_error("jit.gl.hap draw texture to FBO");
jit_gl_hap_draw_end(x);
jit_gl_report_error("jit.gl.hap draw end");
}
else {
jit_object_error((t_object*)x, "could not bind to FBO");
}
glPopClientAttrib();
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, previousFBO);
#ifdef MAC_VERSION
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, previousReadFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, previousDrawFBO);
#endif
x->validframe = 0;
jit_object_notify(x, ps_draw, NULL);
jit_gl_hap_do_report(x);
}
jit_gl_hap_releaseframe(x);
return result;
}
static void draw_galaxy(int i, int j, int f, float a)
{
struct galaxy *g = get_galaxy(i);
float V[6][4];
float p[4] = { 0.0, 0.0, 0.0, 1.0 };
init_galaxy(i);
glPushMatrix();
{
/* Apply the local coordinate system transformation. */
transform_entity(j);
get_viewfrust(V);
get_viewpoint(p);
/* Supply the view position as a vertex program parameter. */
if (GL_has_vertex_program)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 0,
p[0], p[1], p[2], p[3]);
glPushAttrib(GL_ENABLE_BIT |
GL_TEXTURE_BIT |
GL_DEPTH_BUFFER_BIT |
GL_COLOR_BUFFER_BIT);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
{
/* Set up the GL state for star rendering. */
draw_brush(g->brush, a * get_entity_alpha(j));
glBindTexture(GL_TEXTURE_2D, g->texture);
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
glBlendFunc(GL_ONE, GL_ONE);
if (GL_has_vertex_program)
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
if (GL_has_point_sprite)
{
glEnable(GL_POINT_SPRITE_ARB);
glTexEnvi(GL_POINT_SPRITE_ARB,
GL_COORD_REPLACE_ARB, GL_TRUE);
}
draw_arrays(i);
/* Render all stars. */
node_draw(g->N, 0, 0, V);
}
glPopClientAttrib();
glPopAttrib();
/* Render all child entities in this coordinate system. */
draw_entity_tree(j, f, a * get_entity_alpha(j));
}
glPopMatrix();
}
void RRPlugin::readpixels(GLint x, GLint y, GLint w, GLint pitch, GLint h,
GLenum format, int ps, GLubyte *bits, GLint buf)
{
GLint readbuf = GL_BACK;
glGetIntegerv(GL_READ_BUFFER, &readbuf);
//tempctx tc(_localdpy, EXISTING_DRAWABLE, GetCurrentDrawable());
glReadBuffer(buf);
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
if (pitch % 8 == 0)
glPixelStorei(GL_PACK_ALIGNMENT, 8);
else if (pitch % 4 == 0)
glPixelStorei(GL_PACK_ALIGNMENT, 4);
else if (pitch % 2 == 0)
glPixelStorei(GL_PACK_ALIGNMENT, 2);
else if (pitch % 1 == 0)
glPixelStorei(GL_PACK_ALIGNMENT, 1);
int e = glGetError();
while (e != GL_NO_ERROR)
e = glGetError(); // Clear previous error
//_prof_rb.startframe();
glReadPixels(x, y, w, h, format, GL_UNSIGNED_BYTE, bits);
//_prof_rb.endframe(w*h, 0, stereo? 0.5 : 1);
//checkgl("Read Pixels");
// If automatic faker testing is enabled, store the FB color in an
// environment variable so the test program can verify it
if (fconfig.autotest)
{
unsigned char *rowptr, *pixel;
int match = 1;
int color = -1, i, j, k;
color = -1;
//if(buf!=GL_FRONT_RIGHT && buf!=GL_BACK_RIGHT) _autotestframecount++;
for (j = 0, rowptr = bits; j < h && match; j++, rowptr += pitch)
for (i = 1, pixel = &rowptr[ps]; i < w && match; i++, pixel += ps)
for (k = 0; k < ps; k++)
{
if (pixel[k] != rowptr[k])
{
match = 0;
break;
}
}
if (match)
{
if (format == GL_COLOR_INDEX)
{
unsigned char index;
glReadPixels(0, 0, 1, 1, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, &index);
color = index;
}
else
{
unsigned char rgb[3];
glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, rgb);
color = rgb[0] + (rgb[1] << 8) + (rgb[2] << 16);
}
}
}
glPopClientAttrib();
//tc.restore();
glReadBuffer(readbuf);
}
static void draw_terrain(int i, int j, int f, float a)
{
init_terrain(i);
glPushMatrix();
{
float V[6][4], P[16], M[16], X[16], v[4];
float t;
float p;
/* Apply the local coordinate system transformation. */
transform_entity(j);
/* Acquire the model-view-projection matrix. */
glGetFloatv(GL_PROJECTION_MATRIX, P);
glGetFloatv(GL_MODELVIEW_MATRIX, M);
mult_mat_mat(X, P, M);
get_viewfrust(V);
get_viewpoint(v);
/* Set the far clipping plane to the center of the planet. */
/* TODO: fix */
/* V[5][3] = 0.0f; */
/* Determine the viewpoint in cylindrical coordinates. */
normalize(v);
t = (float) DEG(atan2(v[0], v[2]));
p = (float) DEG(acos(-v[1]));
if (t < 0) t += 360.0f;
/* Draw. */
glPushAttrib(GL_POLYGON_BIT | GL_ENABLE_BIT);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
{
float y0 = (p > 90.0f) ? 0.0f : 90.0f;
float y1 = (p > 90.0f) ? 90.0f : 0.0f;
float x0 = (float) fmod(floor(t / 90.0f) * 90.0 + 180.0, 360.0);
float x1 = (float) fmod(floor(t / 90.0f) * 90.0 + 90.0, 360.0);
float x2 = (float) fmod(floor(t / 90.0f) * 90.0 + 270.0, 360.0);
float x3 = (float) fmod(floor(t / 90.0f) * 90.0 + 0.0, 360.0);
int t0 = (int) (y0 / 90.0f);
int t1 = (int) (y1 / 90.0f);
int s0 = (int) (x0 / 90.0f);
int s1 = (int) (x1 / 90.0f);
int s2 = (int) (x2 / 90.0f);
int s3 = (int) (x3 / 90.0f);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
enqueue_area(x0, y0, 90.0f, terrain[i].tex[s0][t0]);
enqueue_area(x1, y0, 90.0f, terrain[i].tex[s1][t0]);
enqueue_area(x2, y0, 90.0f, terrain[i].tex[s2][t0]);
enqueue_area(x3, y0, 90.0f, terrain[i].tex[s3][t0]);
enqueue_area(x0, y1, 90.0f, terrain[i].tex[s0][t1]);
enqueue_area(x1, y1, 90.0f, terrain[i].tex[s1][t1]);
enqueue_area(x2, y1, 90.0f, terrain[i].tex[s2][t1]);
enqueue_area(x3, y1, 90.0f, terrain[i].tex[s3][t1]);
count = 0;
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, terrain[i].ibo);
draw_areas(V, X, i, p, t);
/* printf("%d\n", count); */
glBindTexture (GL_TEXTURE_2D, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
glPopClientAttrib();
glPopAttrib();
/* Render all child entities in this coordinate system. */
draw_entity_tree(j, f, a * get_entity_alpha(j));
}
glPopMatrix();
}
void CGUIFontTTFGL::LastEnd()
{
#ifdef HAS_GL
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glColorPointer (4, GL_UNSIGNED_BYTE, sizeof(SVertex), (char*)&m_vertex[0] + offsetof(SVertex, r));
glVertexPointer (3, GL_FLOAT , sizeof(SVertex), (char*)&m_vertex[0] + offsetof(SVertex, x));
glTexCoordPointer(2, GL_FLOAT , sizeof(SVertex), (char*)&m_vertex[0] + offsetof(SVertex, u));
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_QUADS, 0, m_vertex.size());
glPopClientAttrib();
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
#else
// GLES 2.0 version.
g_Windowing.EnableGUIShader(SM_FONTS);
CreateStaticVertexBuffers();
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
GLint modelLoc = g_Windowing.GUIShaderGetModel();
// Enable the attributes used by this shader
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(colLoc);
glEnableVertexAttribArray(tex0Loc);
if (!m_vertex.empty())
{
// Deal with vertices that had to use software clipping
std::vector<SVertex> vecVertices( 6 * (m_vertex.size() / 4) );
SVertex *vertices = &vecVertices[0];
for (size_t i=0; i<m_vertex.size(); i+=4)
{
*vertices++ = m_vertex[i];
*vertices++ = m_vertex[i+1];
*vertices++ = m_vertex[i+2];
*vertices++ = m_vertex[i+1];
*vertices++ = m_vertex[i+3];
*vertices++ = m_vertex[i+2];
}
vertices = &vecVertices[0];
glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(SVertex), (char*)vertices + offsetof(SVertex, x));
// Normalize color values. Does not affect Performance at all.
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(SVertex), (char*)vertices + offsetof(SVertex, r));
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, GL_FALSE, sizeof(SVertex), (char*)vertices + offsetof(SVertex, u));
glDrawArrays(GL_TRIANGLES, 0, vecVertices.size());
}
if (!m_vertexTrans.empty())
{
// Deal with the vertices that can be hardware clipped and therefore translated
// Bind our pre-calculated array to GL_ELEMENT_ARRAY_BUFFER
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementArrayHandle);
// Store current scissor
CRect scissor = g_graphicsContext.StereoCorrection(g_graphicsContext.GetScissors());
for (size_t i = 0; i < m_vertexTrans.size(); i++)
{
// Apply the clip rectangle
CRect clip = g_Windowing.ClipRectToScissorRect(m_vertexTrans[i].clip);
if (!clip.IsEmpty())
{
// intersect with current scissor
clip.Intersect(scissor);
// skip empty clip
if (clip.IsEmpty())
continue;
g_Windowing.SetScissors(clip);
}
// Apply the translation to the currently active (top-of-stack) model view matrix
glMatrixModview.Push();
glMatrixModview.Get().Translatef(m_vertexTrans[i].translateX, m_vertexTrans[i].translateY, m_vertexTrans[i].translateZ);
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glMatrixModview.Get());
// Bind the buffer to the OpenGL context's GL_ARRAY_BUFFER binding point
glBindBuffer(GL_ARRAY_BUFFER, m_vertexTrans[i].vertexBuffer->bufferHandle);
// Do the actual drawing operation, split into groups of characters no
// larger than the pre-determined size of the element array
for (size_t character = 0; m_vertexTrans[i].vertexBuffer->size > character; character += ELEMENT_ARRAY_MAX_CHAR_INDEX)
{
size_t count = m_vertexTrans[i].vertexBuffer->size - character;
count = std::min<size_t>(count, ELEMENT_ARRAY_MAX_CHAR_INDEX);
// Set up the offsets of the various vertex attributes within the buffer
// object bound to GL_ARRAY_BUFFER
glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, sizeof(SVertex), (GLvoid *) (character*sizeof(SVertex)*4 + offsetof(SVertex, x)));
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(SVertex), (GLvoid *) (character*sizeof(SVertex)*4 + offsetof(SVertex, r)));
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, GL_FALSE, sizeof(SVertex), (GLvoid *) (character*sizeof(SVertex)*4 + offsetof(SVertex, u)));
glDrawElements(GL_TRIANGLES, 6 * count, GL_UNSIGNED_SHORT, 0);
}
glMatrixModview.Pop();
}
// Restore the original scissor rectangle
g_Windowing.SetScissors(scissor);
// Restore the original model view matrix
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glMatrixModview.Get());
// Unbind GL_ARRAY_BUFFER and GL_ELEMENT_ARRAY_BUFFER
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
// Disable the attributes used by this shader
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(colLoc);
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
#endif
}
int PsychDrawText(double xStart, double yStart, int textLen, double* text)
{
int i;
GLuint ti;
QChar* myUniChars = new QChar[textLen];
// On first invocation after init we need to generate a useless texture object.
// This is a weird workaround for some weird bug somewhere in FTGL...
if (_firstCall) {
_firstCall = false;
glGenTextures(1, &ti);
}
// Check if rebuild of font face needed due to parameter
// change. Reload/Rebuild font face if so, check for errors:
if (_needsRebuild && PsychRebuildFont()) return(1);
// Synthesize Unicode QString from double vector:
for(i = 0; i < textLen; i++) {
myUniChars[i] = QChar((unsigned int) text[i]);
}
QString uniCodeText = QString(myUniChars, textLen);
delete [] myUniChars;
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
glEnable( GL_TEXTURE_2D );
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(_vxs, _vxs + _vw, _vys, _vys + _vh);
glMatrixMode(GL_MODELVIEW);
// Set text color: This will be filtered by OGLFT for redundant settings:
if (faceT) {
faceT->setForegroundColor( _fgcolor[0], _fgcolor[1], _fgcolor[2], _fgcolor[3]);
}
else {
faceM->setForegroundColor( _fgcolor[0], _fgcolor[1], _fgcolor[2], _fgcolor[3]);
}
// Rendering of background quad requested? -- True if background alpha > 0.
if (_bgcolor[3] > 0) {
// Yes. Compute bounding box of "to be drawn" text and render a quad in background color:
float xmin, ymin, xmax, ymax;
PsychMeasureText(textLen, text, &xmin, &ymin, &xmax, &ymax);
glColor4fv(&(_bgcolor[0]));
glRectf(xmin + xStart, ymin + yStart, xmax + xStart, ymax + yStart);
}
// Draw the text at selected start location:
if (faceT) {
faceT->draw(xStart, yStart, uniCodeText);
}
else {
faceM->draw(xStart, yStart, uniCodeText);
}
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glDisable( GL_TEXTURE_2D );
glPopAttrib();
glPopClientAttrib();
// Ready!
return(0);
}
//-------------------------------------------
void ofxAssimpModelLoader::draw(ofPolyRenderMode renderType) {
if(scene == NULL) {
return;
}
ofPushStyle();
if(!ofGetGLProgrammableRenderer()){
#ifndef TARGET_OPENGLES
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glPolygonMode(GL_FRONT_AND_BACK, ofGetGLPolyMode(renderType));
#endif
glEnable(GL_NORMALIZE);
}
ofPushMatrix();
ofMultMatrix(modelMatrix);
for(unsigned int i=0; i<modelMeshes.size(); i++) {
ofxAssimpMeshHelper & mesh = modelMeshes[i];
ofPushMatrix();
ofMultMatrix(mesh.matrix);
if(bUsingTextures){
if(mesh.hasTexture()) {
ofTexture * tex = mesh.getTexturePtr();
if(tex->isAllocated()) {
tex->bind();
}
}
}
if(bUsingMaterials){
mesh.material.begin();
}
if(mesh.twoSided) {
glEnable(GL_CULL_FACE);
}
else {
glDisable(GL_CULL_FACE);
}
ofEnableBlendMode(mesh.blendMode);
#ifndef TARGET_OPENGLES
mesh.vbo.drawElements(GL_TRIANGLES,mesh.indices.size());
#else
switch(renderType){
case OF_MESH_FILL:
mesh.vbo.drawElements(GL_TRIANGLES,mesh.indices.size());
break;
case OF_MESH_WIREFRAME:
mesh.vbo.drawElements(GL_LINES,mesh.indices.size());
break;
case OF_MESH_POINTS:
mesh.vbo.drawElements(GL_POINTS,mesh.indices.size());
break;
}
#endif
if(bUsingTextures){
if(mesh.hasTexture()) {
ofTexture * tex = mesh.getTexturePtr();
if(tex->isAllocated()) {
tex->unbind();
}
}
}
if(bUsingMaterials){
mesh.material.end();
}
ofPopMatrix();
}
ofPopMatrix();
if(!ofGetGLProgrammableRenderer()){
#ifndef TARGET_OPENGLES
glPopClientAttrib();
glPopAttrib();
#endif
}
ofPopStyle();
}
void
piglit_init(int argc, char **argv)
{
GLuint obj;
int pass = 1;
void * ptr;
GLenum err;
piglit_require_extension("GL_APPLE_vertex_array_object");
glGenVertexArraysAPPLE(1, & obj);
glBindVertexArrayAPPLE(obj);
glVertexPointer(4, GL_FLOAT, sizeof(GLfloat) * 4, (void *) 0xDEADBEEF);
glEnableClientState(GL_VERTEX_ARRAY);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glDeleteVertexArraysAPPLE(1, & obj);
err = glGetError();
if (err) {
printf("glGetError incorrectly returned 0x%04x.\n", err);
pass = 0;
}
if ((*glIsVertexArrayAPPLE)(obj)) {
printf("Array object is incorrectly still valid.\n");
pass = 0;
}
err = glGetError();
if (err) {
printf("glGetError incorrectly returned 0x%04x.\n", err);
pass = 0;
}
glPopClientAttrib();
err = glGetError();
if (err) {
printf("glGetError incorrectly returned 0x%04x.\n", err);
pass = 0;
}
if (! glIsVertexArrayAPPLE(obj)) {
printf("Array object is incorrectly invalid.\n");
pass = 0;
}
if (! glIsEnabled(GL_VERTEX_ARRAY)) {
printf("Array state is incorrectly disabled.\n");
pass = 0;
}
glGetPointerv(GL_VERTEX_ARRAY_POINTER, & ptr);
if (ptr != (void *) 0xDEADBEEF) {
printf("Array pointer is incorrectly set to 0x%p.\n", ptr);
pass = 0;
}
if (! pass) {
piglit_report_result(PIGLIT_FAIL);
} else {
piglit_report_result(PIGLIT_PASS);
}
}
void large_rocky_body::draw(const simulation_context *sim_context, const drawing_context *draw_context)
{
lithosphere *litho = get_lithosphere();
if (litho)
{
vector pos_in_view = get_modelview() * vector::ZERO;
gsgl::real_t radius = gsgl::max_val(get_polar_radius(), get_equatorial_radius());
gsgl::real_t dist = pos_in_view.mag();
gsgl::real_t zdist = -pos_in_view.get_z();
assert(zdist > 0);
gsgl::real_t far_plane = zdist + (radius * 1.1f);
gsgl::real_t near_plane = zdist - (radius * 1.1f);
if (near_plane <= 0)
near_plane = 1;
display::scoped_perspective proj(*draw_context->screen, draw_context->cam->get_field_of_view(), draw_context->screen->get_aspect_ratio(), near_plane, far_plane);
display::scoped_color cc(*draw_context->screen, color::WHITE);
gsgl::real_t screen_width = utils::pixel_size(dist, radius, draw_context->cam->get_field_of_view(), draw_context->screen->get_height());
if (screen_width < MIN_PIXEL_WIDTH)
{
display::scoped_state state(*draw_context->screen, draw_context->display_flags(this, drawing_context::RENDER_NO_LIGHTING));
set_flags(get_draw_results(), node::NODE_DREW_POINT);
draw_context->screen->draw_point(vector::ZERO, MIN_PIXEL_WIDTH);
}
else
{
display::scoped_state state(*draw_context->screen, draw_context->display_flags(this));
draw_context->screen->clear(display::CLEAR_DEPTH);
display::scoped_modelview mv(*draw_context->screen, &litho->get_modelview());
litho->draw(sim_context, draw_context);
}
// draw name
draw_name(draw_context);
}
else
{
celestial_body::draw(sim_context, draw_context);
}
#if 0
lithosphere *litho = get_lithosphere();
if (litho)
{
glPushAttrib(GL_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); CHECK_GL_ERRORS();
vector ep = utils::pos_in_eye_space(this);
gsgl::real_t radius = gsgl::max_val(get_polar_radius(), get_equatorial_radius());
gsgl::real_t dist = ep.mag();
gsgl::real_t zdist = -ep.get_z();
gsgl::real_t far_plane = zdist + (radius * 1.1f);
gsgl::real_t near_plane = zdist - (radius * 1.1f);
if (near_plane <= 0)
near_plane = 1;
glMatrixMode(GL_PROJECTION); CHECK_GL_ERRORS();
glLoadIdentity(); CHECK_GL_ERRORS();
gluPerspective(draw_context->cam->get_field_of_view(), draw_context->screen->get_aspect_ratio(), near_plane, far_plane); CHECK_GL_ERRORS();
// check to see if we're out of range
gsgl::real_t screen_width = utils::pixel_size(dist, radius, draw_context->cam->get_field_of_view(), draw_context->screen->get_height());
color::WHITE.bind();
if (screen_width < MIN_PIXEL_WIDTH)
{
get_draw_results() |= node::NODE_DREW_POINT;
draw_point(MIN_PIXEL_WIDTH);
}
else
{
glClearDepth(1); CHECK_GL_ERRORS();
glClear(GL_DEPTH_BUFFER_BIT); CHECK_GL_ERRORS();
glEnable(GL_DEPTH_TEST); CHECK_GL_ERRORS();
glEnable(GL_CULL_FACE); CHECK_GL_ERRORS();
glPolygonMode(GL_FRONT_AND_BACK, (draw_context->render_flags & drawing_context::RENDER_WIREFRAME) ? GL_LINE : GL_FILL); CHECK_GL_ERRORS();
// set up lighting
if (!(draw_context->render_flags & drawing_context::RENDER_NO_LIGHTING) && !(get_draw_flags() & NODE_DRAW_UNLIT))
{
glEnable(GL_LIGHTING); CHECK_GL_ERRORS();
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); CHECK_GL_ERRORS();
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); CHECK_GL_ERRORS();
//glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color::WHITE.get_val()); CHECK_GL_ERRORS();
glMaterialfv(GL_FRONT, GL_SPECULAR, color::BLACK.get_val()); CHECK_GL_ERRORS();
glMaterialfv(GL_FRONT, GL_EMISSION, color::BLACK.get_val()); CHECK_GL_ERRORS();
glMaterialf(GL_FRONT, GL_SHININESS, 8); CHECK_GL_ERRORS();
}
// set up texturing
if (!(draw_context->render_flags & drawing_context::RENDER_NO_TEXTURES))
{
glEnable(GL_TEXTURE_2D);
}
// draw lithosphere
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadMatrixf(litho->get_modelview().ptr());
litho->draw(sim_context, draw_context);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
glPopClientAttrib(); CHECK_GL_ERRORS();
glPopAttrib(); CHECK_GL_ERRORS();
draw_name(draw_context, 1, far_plane);
}
else
{
celestial_body::draw(sim_context, draw_context);
}
#endif
} // large_rocky_body::draw()
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
// `取得視窗大小`
int w, h;
GutGetWindowSize(w, h);
// `清除畫面`
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Vector4 camera_lookat(0.0f, 0.0f, 0.0f);
Matrix4x4 ortho_proj = GutMatrixOrthoRH_OpenGL(20.0f, 20.0f, 0.1f, 100.0f);
{
// `前視圖`
glViewport(0, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, -20.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `上視圖`
glViewport(w/2, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, 0.0f, 20.0f);
Vector4 camera_up(0.0f, 1.0f, 0.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `右視圖`
glViewport(0, 0, w/2, h/2);
// view matrix
Vector4 camera_pos(20.0f, 0.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `使用者視角`
glViewport(w/2, 0, w/2, h/2);
// object * view matrix
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
g_view_matrix = object_matrix * view_matrix;
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&g_projection_matrix[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `畫出viewport的邊界`
glViewport(0, 0, w, h);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// worldview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// `畫邊界`
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_Border);
glDrawArrays(GL_LINES, 0, 4);
glPopClientAttrib();
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
void PowerVBO::display()
{
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
if (mTypes & PVBO_VERTEX ) glEnableClientState(GL_VERTEX_ARRAY);
if (mTypes & PVBO_NORMAL ) glEnableClientState(GL_NORMAL_ARRAY);
if (mTypes & PVBO_TEXTURE) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (mTypes & PVBO_COLOR ) glEnableClientState(GL_COLOR_ARRAY);
if (mTypes & PVBO_COLOR2 ) glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
for (size_t i = 0; i < mVertices.size(); ++i)
{
PowerVertexArray& pva = mVertices[i];
glBindBuffer(GL_ARRAY_BUFFER, pva.binding);
switch (pva.type)
{
case PVBO_VERTEX:
{
glVertexPointer(pva.valuesPerVertex, GL_FLOAT, 0, 0);
break;
}
case PVBO_NORMAL:
{
glNormalPointer(GL_FLOAT, 0, 0);
break;
}
case PVBO_TEXTURE:
{
glTexCoordPointer(pva.valuesPerVertex, GL_FLOAT, 0, 0);
break;
}
case PVBO_COLOR:
{
glColorPointer(pva.valuesPerVertex, GL_FLOAT, 0, 0);
break;
}
case PVBO_COLOR2:
{
glSecondaryColorPointer(pva.valuesPerVertex, GL_FLOAT, 0, 0);
break;
}
default:
{
cerr << "PowerVBO::display() -- invalid array type -- "
<< pva.type << endl;
exit(1);
}
}
}
for (size_t i = 0; i < mIndices.size(); ++i)
{
PowerIndexArray& pia = mIndices[i];
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pia.binding);
glDrawElements(pia.drawMode, pia.size, GL_UNSIGNED_INT, 0);
}
glPopClientAttrib();
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
void DrawCube ( float size )
{
#if 0
glBegin ( GL_QUADS );
glColor3f ( 0.0f, 0.0f, 1.0f );
glVertex3f ( size, size, -size );
glVertex3f ( -size, size, -size );
glVertex3f ( -size, size, size );
glVertex3f ( size, size, size );
glColor3f ( 1.0f, 0.5f, 0.0f );
glVertex3f ( size, -size, size );
glVertex3f ( -size, -size, size );
glVertex3f ( -size, -size, -size );
glVertex3f ( size, -size, -size );
glColor3f ( 1.0f, 0.0f, 0.0f );
glVertex3f ( size, size, size );
glVertex3f ( -size, size, size );
glVertex3f ( -size, -size, size );
glVertex3f ( size, -size, size );
glColor3f ( 1.0f, 1.0f, 0.0f );
glVertex3f ( size, -size, -size );
glVertex3f ( -size, -size, -size );
glVertex3f ( -size, size, -size );
glVertex3f ( size, size, -size );
glColor3f ( 0.0f, 1.0f, 0.0f );
glVertex3f ( -size, size, size );
glVertex3f ( -size, size, -size );
glVertex3f ( -size, -size, -size );
glVertex3f ( -size, -size, size );
glColor3f ( 1.0f, 0.0f, 1.0f );
glVertex3f ( size, size, -size );
glVertex3f ( size, size, size );
glVertex3f ( size, -size, size );
glVertex3f ( size, -size, -size );
glEnd();
#else
float cube [] =
{
size, size, -size ,
0.0f, 0.0f, 1.0f ,
-size, size, -size ,
0.0f, 0.0f, 1.0f ,
-size, size, size ,
0.0f, 0.0f, 1.0f ,
size, size, size ,
0.0f, 0.0f, 1.0f ,
size, -size, size ,
1.0f, 0.5f, 0.0f ,
-size, -size, size ,
1.0f, 0.5f, 0.0f ,
-size, -size, -size ,
1.0f, 0.5f, 0.0f ,
size, -size, -size ,
1.0f, 0.5f, 0.0f ,
size, size, size ,
1.0f, 0.0f, 0.0f ,
-size, size, size ,
1.0f, 0.0f, 0.0f ,
-size, -size, size ,
1.0f, 0.0f, 0.0f ,
size, -size, size ,
1.0f, 0.0f, 0.0f ,
size, -size, -size ,
1.0f, 1.0f, 0.0f ,
-size, -size, -size ,
1.0f, 1.0f, 0.0f ,
-size, size, -size ,
1.0f, 1.0f, 0.0f ,
size, size, -size ,
1.0f, 1.0f, 0.0f ,
-size, size, size ,
0.0f, 1.0f, 0.0f ,
-size, size, -size ,
0.0f, 1.0f, 0.0f ,
-size, -size, -size ,
0.0f, 1.0f, 0.0f ,
-size, -size, size ,
0.0f, 1.0f, 0.0f ,
size, size, -size ,
1.0f, 0.0f, 1.0f ,
size, size, size ,
1.0f, 0.0f, 1.0f ,
size, -size, size ,
1.0f, 0.0f, 1.0f ,
size, -size, -size ,
1.0f, 0.0f, 1.0f
};
glVertexPointer ( 3, GL_FLOAT, sizeof ( float ) * 6, cube );
glColorPointer ( 3, GL_FLOAT, sizeof ( float ) * 6, cube + 3 );
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT );
glEnableClientState ( GL_VERTEX_ARRAY );
glEnableClientState ( GL_COLOR_ARRAY );
glDrawArrays ( GL_QUADS, 0, 24 );
glPopClientAttrib();
#endif
}
void Sample_08::restoreGL()
{
// restore server and client attributes (states)
glPopClientAttrib();
glPopAttrib();
}
void SSEffect::render(GLuint posVBO, GLuint colVBO, unsigned int num, RTPSSettings* settings, const Light* light,const Material* material, float scale, GLuint sceneTex, GLuint sceneDepthTex, GLuint framebuffer)
{
if(num==0)
return;
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
currentDepthBuffer="depth";
bool blending = settings->GetSettingAs<bool>("blending","1");
//QT send 2 for check boxes when enable(due to the possiblity of adding a tristate option.
//Apparently the default string-to-bool conversion is true for 1 and false otherwise
//I need it to be false for 0 and true otherwise.
//bool thickness = !settings->GetSettingAs<int>("thickness","1");
bool thickness = settings->GetSettingAs<bool>("thickness","1");
//perserve original buffer
GLint buffer;
glGetIntegerv(GL_DRAW_BUFFER,&buffer);
glClearColor(0.0f,0.0f,0.0f,0.0f);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,m_fbos[0]);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
//Should probably conditionally create the thickness buffer as well.
//Render Thickness buffer.
if(thickness)
{
m_timers["render_thickness"]->start();
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//give the fluid some thickness everywhere
glClearColor(0.1f,0.1f,0.1f,1.0f);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
//glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClear(GL_COLOR_BUFFER_BIT);
renderPointsAsSpheres( m_shaderLibrary->shaders["sphereThicknessShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
//renderPointsAsSpheres( m_shaderLibrary->shaders["sphereShader"].getProgram(),posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_thickness"]->stop();
m_timers["blur_thickness"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"],0);
GLuint program= m_shaderLibrary->shaders["fixedWidthGaussianShader"].getProgram();
glEnable(GL_TEXTURE_2D);
float xdir[] = {1.0f/height,0.0f};
float ydir[] = {0.0f,1.0f/width};
glUseProgram(program);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glUniform1i( glGetUniformLocation(program, "imgTex"),0);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,xdir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness2"]);
glUniform2fv( glGetUniformLocation(program, "dTex"),1,ydir);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
RenderUtils::fullscreenQuad();
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_TEXTURE_2D);
glFinish();
m_timers["blur_thickness"]->stop();
}
//glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,framebuffer);
m_timers["render_spheres"]->start();
//Render Color and depth buffer of spheres.
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);
glEnable(GL_TEXTURE_2D);
GLuint sphereProgram = m_shaderLibrary->shaders["sphereShader"].getProgram();
glBindTexture(GL_TEXTURE_2D,sceneDepthTex);
glUseProgram(sphereProgram);
glUniform1i(glGetUniformLocation(sphereProgram,"sceneDepth"),0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderPointsAsSpheres(sphereProgram,posVBO, colVBO, num,settings, light,material,scale);
glFinish();
m_timers["render_spheres"]->stop();
//Smooth the depth texture to emulate a surface.
m_timers["smooth_depth"]->start();
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth2"],0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
currentDepthBuffer="depth2";
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
smoothDepth(settings);
glFinish();
m_timers["smooth_depth"]->stop();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer],0);
//Switch to the buffer that was written to in the smoothing step
if(currentDepthBuffer=="depth2")
currentDepthBuffer="depth";
else
currentDepthBuffer="depth2";
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
//if (blending)
//{
//glDepthMask(GL_FALSE);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"],0);
m_timers["calculate_normals"]->start();
//Now we use the depth to normal shader which converts screenspace depth into
//world coordinates and then computes lighting.
glClear(GL_COLOR_BUFFER_BIT);
GLuint normalProgram = m_shaderLibrary->shaders["depth2NormalShader"].getProgram();
glUseProgram(normalProgram);
glUniform1i( glGetUniformLocation(normalProgram, "depthTex"),0);
glUniform1f( glGetUniformLocation(normalProgram, "del_x"),1.0/((float)width));
glUniform1f( glGetUniformLocation(normalProgram, "del_y"),1.0/((float)height));
RenderUtils::fullscreenQuad();
glFinish();
m_timers["calculate_normals"]->stop();
m_timers["render_composite"]->start();
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["Color"],0);
GLuint compositeProgram = m_shaderLibrary->shaders["compositeFluidShader"].getProgram();
glUseProgram(compositeProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,sceneTex);
glUniform1i( glGetUniformLocation(compositeProgram, "depthTex"),0);
glUniform1i( glGetUniformLocation(compositeProgram, "normalTex"),1);
glUniform1i( glGetUniformLocation(compositeProgram, "thicknessTex"),2);
glUniform1i( glGetUniformLocation(compositeProgram, "sceneTex"),3);
glUniform1f( glGetUniformLocation(compositeProgram, "gamma"),settings->GetSettingAs<float>("thickness_gamma","0.1"));
//dout<<"Here"<<endl;
if(material)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&material->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&material->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&material->ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&material->shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&material->opacity);
}
else
{
Material defaultMat;
defaultMat.ambient=float3(0.05f,0.075f,0.25f);
defaultMat.diffuse=float3(0.05f,0.075f,0.25f);
defaultMat.specular=float3(1.0f,1.f,1.0f);
defaultMat.opacity=0.5;
defaultMat.shininess=100;
glUniform3fv(glGetUniformLocation(compositeProgram,"material.diffuse"),1,&defaultMat.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.specular"),1,&defaultMat.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"material.ambient"),1,&defaultMat.ambient.x);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.shininess"),1,&defaultMat.shininess);
glUniform1fv(glGetUniformLocation(compositeProgram,"material.opacity"),1,&defaultMat.opacity);
}
if(light)
{
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&light->diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&light->specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&light->ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&light->pos.x);
}
else
{
Light defaultLight;
defaultLight.ambient = float3(0.2f,0.2f,0.2f);
defaultLight.diffuse = float3(1.0f,1.0f,1.0f);
defaultLight.specular = float3(1.0f,1.0f,1.0f);
defaultLight.pos = float3(5.0f,10.0f,-5.0f);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.diffuse"),1,&defaultLight.diffuse.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.specular"),1,&defaultLight.specular.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.ambient"),1,&defaultLight.ambient.x);
glUniform3fv(glGetUniformLocation(compositeProgram,"light.position"),1,&defaultLight.pos.x);
}
RenderUtils::fullscreenQuad();
glFinish();
m_timers["render_composite"]->stop();
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,0);
//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,framebuffer);
m_timers["copy_to_fbo"]->start();
glDrawBuffer(buffer);
glActiveTexture(GL_TEXTURE0);
GLuint copyProgram = m_shaderLibrary->shaders["copyShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
if(settings->GetSettingAs<bool>("render_composite","1"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
else if(settings->GetSettingAs<bool>("render_normal","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["normalColor"]);
copyProgram = m_shaderLibrary->shaders["copyInverseShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "colorTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth","0"))
{
if(currentDepthBuffer=="depth2")
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth"]);
else
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["depth2"]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_depth_smoothed","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
copyProgram = m_shaderLibrary->shaders["copyDepthColorShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else if(settings->GetSettingAs<bool>("render_thickness","0"))
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"]);
copyProgram = m_shaderLibrary->shaders["copyScalarShader"].getProgram();
glUniform1i( glGetUniformLocation(copyProgram, "scalarTex"),0);
}
else
{
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs["Color"]);
}
//need to copy the contents to the back buffer. It's important that we copy the
//depth as well. Otherwise anything drawn afterwards may incorrecly occlude the fluid.
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_glFramebufferTexs[currentDepthBuffer]);
glUseProgram(copyProgram);
glUniform1i( glGetUniformLocation(copyProgram, "depthTex"),1);
RenderUtils::fullscreenQuad();
glFinish();
m_timers["copy_to_fbo"]->stop();
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,0);
//if (blending)
//{
//glDisable(GL_BLEND);
//}
glPopAttrib();
glPopClientAttrib();
if (m_writeFramebuffers)
{
glFinish();
writeFramebufferTextures();
m_writeFramebuffers = false;
}
}
//-------------------------------------------
void ofxAssimpModelLoader::draw(ofPolyRenderMode renderType)
{
if(scene){
ofPushStyle();
#ifndef TARGET_OPENGLES
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glPolygonMode(GL_FRONT_AND_BACK, ofGetGLPolyMode(renderType));
#endif
glEnable(GL_NORMALIZE);
ofPushMatrix();
ofTranslate(pos);
ofRotate(180, 0, 0, 1);
ofTranslate(-scene_center.x, -scene_center.y, scene_center.z);
if(normalizeScale)
{
ofScale(normalizedScale , normalizedScale, normalizedScale);
}
for(int i = 0; i < (int)rotAngle.size(); i++){
ofRotate(rotAngle[i], rotAxis[i].x, rotAxis[i].y, rotAxis[i].z);
}
ofScale(scale.x, scale.y, scale.z);
if(getAnimationCount())
{
updateGLResources();
}
for(int i = 0; i < (int)modelMeshes.size(); i++){
ofxAssimpMeshHelper & meshHelper = modelMeshes.at(i);
// Texture Binding
if(bUsingTextures && meshHelper.texture.isAllocated()){
meshHelper.texture.bind();
}
if(bUsingMaterials){
meshHelper.material.begin();
}
// Culling
if(meshHelper.twoSided)
glEnable(GL_CULL_FACE);
else
glDisable(GL_CULL_FACE);
ofEnableBlendMode(meshHelper.blendMode);
#ifndef TARGET_OPENGLES
meshHelper.vbo.drawElements(GL_TRIANGLES,meshHelper.indices.size());
#else
switch(renderType){
case OF_MESH_FILL:
meshHelper.vbo.drawElements(GL_TRIANGLES,meshHelper.indices.size());
break;
case OF_MESH_WIREFRAME:
meshHelper.vbo.drawElements(GL_LINES,meshHelper.indices.size());
break;
case OF_MESH_POINTS:
meshHelper.vbo.drawElements(GL_POINTS,meshHelper.indices.size());
break;
}
#endif
// Texture Binding
if(bUsingTextures && meshHelper.texture.bAllocated()){
meshHelper.texture.unbind();
}
if(bUsingMaterials){
meshHelper.material.end();
}
}
ofPopMatrix();
#ifndef TARGET_OPENGLES
glPopClientAttrib();
glPopAttrib();
#endif
ofPopStyle();
}
}
void R_RemapDeluxeImages( world_t *world )
{
int i;
if( !tr.deluxemaps[0] )
return;
R_InitConverter();
R_StateSetActiveTmuUntracked( GL_TEXTURE0 );
R_StateSetActiveClientTmuUntracked( GL_TEXTURE0 );
glPushAttrib( GL_ALL_ATTRIB_BITS );
glPushClientAttrib( GL_CLIENT_ALL_ATTRIB_BITS );
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
glEnableVertexAttribArrayARB( 6 );
glEnableVertexAttribArrayARB( 7 );
glClearColor( 0, 0, 0, 0 );
glDisable( GL_DEPTH_TEST );
glDisable( GL_STENCIL_TEST );
glDisable( GL_ALPHA_TEST );
glDisable( GL_BLEND );
glDisable( GL_CULL_FACE );
glDisable( GL_MULTISAMPLE );
glEnable( GL_POLYGON_SMOOTH );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glEnable( GL_VERTEX_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, conv.vp );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, conv.fp );
glEnable( GL_TEXTURE_2D );
for( i = 0; i < tr.numLightmaps; i++ )
{
int j, y;
unsigned *buf0, *buf1;
image_t *img = tr.deluxemaps[i];
glBindTexture( GL_TEXTURE_2D, img->texnum );
glClear( GL_COLOR_BUFFER_BIT );
glViewport( 0, img->uploadHeight, img->uploadWidth, img->uploadHeight );
glDisable( GL_VERTEX_PROGRAM_ARB );
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glBegin( GL_QUADS );
{
glTexCoord2f( 0, 0 );
glVertex2f( -1, -1 );
glTexCoord2f( 0, 1 );
glVertex2f( -1, 1 );
glTexCoord2f( 1, 1 );
glVertex2f( 1, 1 );
glTexCoord2f( 1, 0 );
glVertex2f( 1, -1 );
}
glEnd();
glEnable( GL_VERTEX_PROGRAM_ARB );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glViewport( 0, 0, img->uploadWidth, img->uploadHeight );
glProgramLocalParameter4fARB( GL_VERTEX_PROGRAM_ARB, 0,
img->uploadWidth, img->uploadHeight,
1.0F / img->uploadWidth, 1.0F / img->uploadHeight );
for( j = 0; j < world->numsurfaces; j++ )
{
const msurface_t *srf = world->surfaces + j;
const shader_t *shader = srf->shader;
const msurface_ex_t *exsrf = srf->redirect;
if( !shader->stages[0] || !shader->stages[0]->active )
continue;
if( shader->stages[0]->deluxeMap != img )
continue;
if( !exsrf )
continue;
glVertexPointer( 2, GL_FLOAT, sizeof( drawVert_ex_t ),
&exsrf->verts[0].uvL );
glNormalPointer( GL_FLOAT, sizeof( drawVert_ex_t ),
&exsrf->verts[0].norm );
glVertexAttribPointerARB( 6, 3, GL_FLOAT, GL_FALSE,
sizeof( drawVert_ex_t ), &exsrf->verts[0].tan );
glVertexAttribPointerARB( 7, 3, GL_FLOAT, GL_FALSE,
sizeof( drawVert_ex_t ), &exsrf->verts[0].bin );
glDrawElements( exsrf->primType, exsrf->numIndices,
GL_UNSIGNED_SHORT, exsrf->indices );
}
glFinish();
buf0 = (unsigned*)ri.Hunk_AllocateTempMemory( img->uploadWidth * img->uploadHeight * 4 );
buf1 = (unsigned*)ri.Hunk_AllocateTempMemory( img->uploadWidth * img->uploadHeight * 4 );
//can't just copy to the texture since we
//need the custom mipmap generator
glReadPixels( 0, 0, img->uploadWidth, img->uploadHeight,
GL_RGBA, GL_UNSIGNED_BYTE, buf0 );
#define DELUXEL( buf, x, y ) ((byte*)(buf) + (((y) * img->uploadWidth + (x)) * 4))
Com_Memcpy( buf1, buf0, img->uploadWidth * img->uploadHeight * 4 );
for( j = 0; j < 4; j++ )
{
for( y = 0; y < img->uploadHeight; y++ )
{
int x;
for( x = 0; x < img->uploadWidth; x++ )
{
static int neighbors[8][2] =
{
{ 0, 1 },
{ 1, 1 },
{ 1, 0 },
{ 1, -1 },
{ 0, -1 },
{ -1, -1 },
{ -1, 0 },
{ -1, 1 }
};
int i;
int sum[3], c;
byte *cIn = DELUXEL( buf0, x, y );
byte *cOut = DELUXEL( buf1, x, y );
cOut[3] = cIn[3];
if( cIn[2] )
{
//if it has some Z value
//then it's already good
cOut[0] = cIn[0];
cOut[1] = cIn[1];
cOut[2] = cIn[2];
continue;
}
c = 0;
sum[0] = sum[1] = sum[2] = 0;
for( i = 0; i < lengthof( neighbors ); i++ )
{
int nx = x + neighbors[i][0];
int ny = y + neighbors[i][1];
if( nx >= 0 && nx < img->uploadWidth &&
ny >= 0 && ny < img->uploadHeight )
{
byte *n = DELUXEL( buf0, nx, ny );
if( !n[2] )
continue;
sum[0] += n[0];
sum[1] += n[1];
sum[2] += n[2];
c++;
}
}
if( c )
{
cOut[0] = sum[0] / c;
cOut[1] = sum[1] / c;
cOut[2] = sum[2] / c;
}
}
}
Com_Memcpy( buf0, buf1, img->uploadWidth * img->uploadHeight * 4 );
}
for( y = 0; y < img->uploadHeight; y++ )
{
int x;
for( x = 0; x < img->uploadWidth; x++ )
{
byte *d = DELUXEL( buf1, x, y );
if( !d[2] )
{
d[0] = 0;
d[1] = 0;
d[2] = 0xFF;
}
}
}
//write it out to file
{
int size;
char path[MAX_QPATH];
byte *out_buf;
Com_sprintf( path, sizeof( path ), "deluxe/%s/dm_%04d.tga",
world->baseName, i );
size = 18 + img->uploadWidth * img->uploadHeight * 3;
out_buf = (byte*)ri.Hunk_AllocateTempMemory( size );
Com_Memset( out_buf, 0, 18 );
out_buf[2] = 2; // uncompressed type
out_buf[12] = img->uploadWidth & 255;
out_buf[13] = img->uploadWidth >> 8;
out_buf[14] = img->uploadHeight & 255;
out_buf[15] = img->uploadHeight >> 8;
out_buf[16] = 24; // pixel size
out_buf[17] = 0x20; // reverse row order
for( y = 0; y < img->uploadHeight; y++ )
{
int x;
for( x = 0; x < img->uploadWidth; x++ )
{
byte *d = DELUXEL( buf1, x, y );
out_buf[18 + (y * img->uploadWidth + x) * 3 + 0] = d[2];
out_buf[18 + (y * img->uploadWidth + x) * 3 + 1] = d[1];
out_buf[18 + (y * img->uploadWidth + x) * 3 + 2] = d[0];
}
}
ri.FS_WriteFile( path, out_buf, size );
ri.Hunk_FreeTempMemory( out_buf );
}
#undef DELUXEL
Upload32( buf1, qfalse, img, ILF_VECTOR_SB3 );
#ifdef _DEBUG
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, img->texnum );
glViewport( img->uploadWidth, 0, img->uploadWidth, img->uploadHeight );
glDisable( GL_VERTEX_PROGRAM_ARB );
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glBegin( GL_QUADS );
{
glTexCoord2f( 0, 0 );
glVertex2f( -1, -1 );
glTexCoord2f( 0, 1 );
glVertex2f( -1, 1 );
glTexCoord2f( 1, 1 );
glVertex2f( 1, 1 );
glTexCoord2f( 1, 0 );
glVertex2f( 1, -1 );
}
glEnd();
glEnable( GL_VERTEX_PROGRAM_ARB );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
GLimp_EndFrame();
#endif
ri.Hunk_FreeTempMemory( buf1 );
ri.Hunk_FreeTempMemory( buf0 );
}
glPopClientAttrib();
glPopAttrib();
glDeleteProgramsARB( 1, &conv.vp );
glDeleteProgramsARB( 1, &conv.fp );
}
