// 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 ); }