void drawComponentBuffer() { #if ! JUCE_ANDROID glEnable (GL_TEXTURE_2D); clearGLError(); #endif context.extensions.glActiveTexture (GL_TEXTURE0); glBindTexture (GL_TEXTURE_2D, cachedImageFrameBuffer.getTextureID()); const Rectangle<int> cacheBounds (cachedImageFrameBuffer.getWidth(), cachedImageFrameBuffer.getHeight()); context.copyTexture (cacheBounds, cacheBounds, cacheBounds.getWidth(), cacheBounds.getHeight()); glBindTexture (GL_TEXTURE_2D, 0); JUCE_CHECK_OPENGL_ERROR }
void OpenGLHelpers::drawTriangleStrip (const GLfloat* const vertices, const GLfloat* const textureCoords, const int numVertices) noexcept { #if ! JUCE_ANDROID glEnable (GL_TEXTURE_2D); clearGLError(); #endif glDisableClientState (GL_COLOR_ARRAY); glDisableClientState (GL_NORMAL_ARRAY); glEnableClientState (GL_VERTEX_ARRAY); glVertexPointer (2, GL_FLOAT, 0, vertices); glEnableClientState (GL_TEXTURE_COORD_ARRAY); glTexCoordPointer (2, GL_FLOAT, 0, textureCoords); glDrawArrays (GL_TRIANGLE_STRIP, 0, numVertices); }
bool AndroidGraphicBuffer::Bind() { if (!EnsureInitialized()) return false; if (!EnsureEGLImage()) { LOG("No valid EGLImage!"); return false; } clearGLError(); sGLFunctions.fImageTargetTexture2DOES(GL_TEXTURE_2D, mEGLImage); return ensureNoGLError("glEGLImageTargetTexture2DOES"); }
bool renderFrame() { ScopedPointer<MessageManagerLock> mmLock; const bool isUpdating = needsUpdate.compareAndSetBool (0, 1); if (context.renderComponents && isUpdating) { mmLock = new MessageManagerLock (this); // need to acquire this before locking the context. if (! mmLock->lockWasGained()) return false; } if (! context.makeActive()) return false; NativeContext::Locker locker (*nativeContext); JUCE_CHECK_OPENGL_ERROR if (context.renderer != nullptr) { glViewport (0, 0, viewportArea.getWidth(), viewportArea.getHeight()); context.renderer->renderOpenGL(); clearGLError(); } if (context.renderComponents) { if (isUpdating) { paintComponent(); mmLock = nullptr; } glViewport (0, 0, viewportArea.getWidth(), viewportArea.getHeight()); drawComponentBuffer(); } context.swapBuffers(); return true; }
bool renderFrame() { if (! context.makeActive()) return false; NativeContext::Locker locker (*nativeContext); JUCE_CHECK_OPENGL_ERROR glViewport (0, 0, component.getWidth(), component.getHeight()); if (context.renderer != nullptr) { context.renderer->renderOpenGL(); clearGLError(); } if (context.renderComponents) paintComponent(); context.swapBuffers(); return true; }
/** Draw a tree. \param node Node \param draw_blends If true, only objects that use blending are drawn. Otherwise objects with blending are not drawn. \return True if the tree contained one or more objects that use blending */ bool GLRenderInstance::drawNode(WorldObject& node, bool draw_blends) { double M[16]; BoundingBox bb; vec3d bmin, bmax, t, d; bool render_flag = true; bool res = false; WorldObject::ChildIterator it; for(it=node.childsBegin(); it!=node.childsEnd(); it++) { glPushMatrix(); // Set the local transformation it->second->localTransform().toList(M); glMultMatrixd(M); // Draw the geom (if visible) boost::shared_ptr<GeomObject> geom = it->second->getGeom(); if (geom.get()!=0 && (it->second->visible.getValue())) { // Render by default if draw_blends is false render_flag = !draw_blends; // Set material boost::shared_ptr<Material> mat = it->second->getMaterial(); Material* bmat = dynamic_cast<Material*>(mat.get()); // Check if the object should be postponed because blending is used... if (bmat!=0) { if (bmat->usesBlending()) { res = true; render_flag = draw_blends; } } if (render_flag) { // Set material glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT); if (bmat!=0) { bmat->applyGL(); } if (draw_solid) { clearGLError(); geom->drawGL(); } // Draw bounding box if (draw_bboxes) { bb = geom->boundingBox(); if (!bb.isEmpty()) { glDisable(GL_LIGHTING); bb.getBounds(bmin, bmax); t = 0.5*(bmax+bmin); d = bmax-bmin; glPushMatrix(); glTranslated(t.x, t.y, t.z); drawWireCube(d.x, d.y, d.z); glPopMatrix(); glEnable(GL_LIGHTING); } } glPopAttrib(); // restore material } } // Draw the children res |= drawNode(*(it->second), draw_blends); glPopMatrix(); } return res; }
/** Draw the current scene. \todo Lichtquellen am Anfang disablen */ void GLRenderInstance::paint(WorldObject& root) { double M[16]; if (stereo_mode==2) { // Switch to both back buffers for initialization... glDrawBuffer(GL_BACK); } // Viewport glViewport(viewx, viewy, viewwidth, viewheight); // Initialize glClearColor(GLfloat(clearcol.x), GLfloat(clearcol.y), GLfloat(clearcol.z), GLfloat(clearcol.w)); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); // glDisable(GL_LIGHTING); glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); if (smooth_model) glShadeModel(GL_SMOOTH); else glShadeModel(GL_FLAT); // Enable backface culling if (backface_culling) { glFrontFace(GL_CCW); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); } else glDisable(GL_CULL_FACE); // glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_DIFFUSE); if (separate_specular_color) glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); else glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR); clearGLError(); // GL_LIGHT_MODEL_COLOR_CONTROL is not supported in OpenGL 1.1 glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); // glEnable(GL_LINE_SMOOTH); // glEnable(GL_BLEND); // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // glDisable(GL_LIGHTING) switch(polygon_mode) { case 0: glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); break; case 1: glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break; case 2: glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; } // Projection glMatrixMode(GL_PROJECTION); projectionmatrix.toList(M, false); glLoadMatrixd(M); // Initialize ModelView matrix glMatrixMode(GL_MODELVIEW); switch(stereo_mode) { case 1: glViewport(viewx, viewy, viewwidth/2, viewheight); break; case 2: glDrawBuffer(GL_BACK_LEFT); break; } // Draw the scene drawScene(root, viewmatrix1); switch(stereo_mode) { case 1: // Draw right image glViewport(viewx+viewwidth/2, viewy, viewwidth/2, viewheight); drawScene(root, viewmatrix2); break; case 2: glDrawBuffer(GL_BACK_RIGHT); // Draw right image glClear(GL_DEPTH_BUFFER_BIT); drawScene(root, viewmatrix2); glDrawBuffer(GL_BACK); break; } // Draw the orientation as a small coordinate system in the lower left corner if (draw_orientation) { glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glViewport(0, 0, 48, 48); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1,1,-1,1,-1,1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if (left_handed) glScaled(-1,1,1); glScalef(GLfloat(0.9), GLfloat(0.9), GLfloat(0.9)); glRotated(180,0,1,0); mat4d V2(viewmatrix1); V2.setColumn(3, 0,0,0,1); V2.toList(M, false); glMultMatrixd(M); drawCoordSystem(); if (stereo_mode==1) { glViewport(viewwidth/2, 0, 48, 48); drawCoordSystem(); } } // HUD-Test /* glViewport(viewx, viewy, viewwidth, viewheight); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glDisable(GL_NORMALIZE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0,1, 0,1, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3d(0,1,0); glBegin(GL_LINES); glVertex2d(0,0); glVertex2d(1,1); glEnd();*/ clearGLError(); // final cleanup }