int glDrawViewport(viewport_t *v){ framebuffer_t *df = returnFramebufferById(v->dfbid); framebuffer_t *of = returnFramebufferById(v->outfbid); if(!df || !of) return FALSE; //glBindFramebuffer(GL_FRAMEBUFFER, df->id); bindFramebuffer(df); // GLenum buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2}; // glDrawBuffers(3, buffers); // glBindFramebuffer(GL_FRAMEBUFFER, of->id); states_depthMask(GL_TRUE);//needs this to be true to clear it glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT| GL_STENCIL_BUFFER_BIT);//todo set OF to use the same renderbuffer for depth as DF // glClear( GL_STENCIL_BUFFER_BIT);//todo set OF to use the same renderbuffer for depth as DF // glViewport(0, 0, df->width, df->height); // glStencilFunc(GL_ALWAYS, 1, 0xFF); // glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); // glStencilMask(0xFF); // glViewport(0, 0, of->width, of->height); // renderbatche_t b; // memset(&b, 0, sizeof(renderbatche_t)); // loadEntitiesIntoQueues(&forward, &deferred, v); loadWorldIntoQueues(&forward, &deferred, v); // loadEntitiesIntoQueue(&deferred, v); // loadWorldIntoQueue(&deferred, v); renderqueueRadixSort(&deferred); renderqueueSetup(&deferred); renderqueueDraw(&deferred); // renderqueueCleanup(&deferred); glDeferredLighting(v, &forward); renderqueueRadixSort(&forward); renderqueueSetup(&forward); renderqueueDraw(&forward); //todo actually redo this sorta stuffs shaderprogram_t * shader = shader_returnById(fsblendshaderid); shaderpermutation_t * perm = shader_addPermutationToProgram(shader, 0); model_t * m = model_returnById(fsquadmodel); vbo_t * tvbo = returnVBOById(m->vbo); // glstate_t s = {STATESENABLEBLEND, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_LESS, GL_BACK, GL_FALSE, GL_LESS, 0.0, tvbo->vaoid, renderqueueuboid, GL_UNIFORM_BUFFER, 0, 0, 0, perm->id}; glstate_t s = {STATESENABLEBLEND, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_LESS, GL_BACK, GL_FALSE, GL_LESS, 0.0, tvbo->vaoid, 0, 0, 0, 0, 0, perm->id, 0, {0}, {0}, {renderqueueuboid, 0}, {0}, {0}}; states_setState(s); states_bindActiveTexture(0, GL_TEXTURE_2D, df->textures[2].id); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); return TRUE; }
void GraphicsContext3DPrivate::deleteFramebuffer(Platform3DObject framebuffer) { makeContextCurrent(); if (framebuffer == m_boundFBO) { // Make sure the framebuffer is not going to be used for drawing // operations after it gets deleted. bindFramebuffer(FRAMEBUFFER, 0); } m_api->glDeleteFramebuffers(1, &framebuffer); }
void QKmsScreen::swapBuffers() { waitForPageFlipComplete(); if ( m_flipReady ) performPageFlip(); //TODO: Do something with return value here m_bufferManager.nextBuffer(); //qDebug() << "swapBuffers now rendering to " << m_bufferManager.renderTargetBuffer(); bindFramebuffer(); }
void StateManagerGL::deleteFramebuffer(GLuint fbo) { if (fbo != 0) { for (size_t binding = 0; binding < mFramebuffers.size(); ++binding) { if (mFramebuffers[binding] == fbo) { GLenum enumValue = angle::FramebufferBindingToEnum( static_cast<angle::FramebufferBinding>(binding)); bindFramebuffer(enumValue, 0); } mFunctions->deleteFramebuffers(1, &fbo); } } }
int glDeferredLighting(viewport_t *v, renderqueue_t * q){ framebuffer_t *df = returnFramebufferById(v->dfbid); framebuffer_t *of = returnFramebufferById(v->outfbid); unsigned int numsamples = df->rbflags & FRAMEBUFFERRBFLAGSMSCOUNT; if(numsamples){ numsamples = 1<<numsamples; // resolveMultisampleFramebuffer(df); //only resolves if multisampled resolveMultisampleFramebufferSpecify(df, 4); } bindFramebuffer(of); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT| GL_STENCIL_BUFFER_BIT);//todo set OF to use the same renderbuffer for depth as DF // glClearBufferfi(of->rb, GLint drawBuffer, GLfloat depth, GLint stencil); glViewport(0, 0, of->width, of->height); CHECKGLERROR if(numsamples){ // glUniform1i(shaderCurrentBound->uniint0, numsamples); states_bindActiveTexture(0, GL_TEXTURE_2D_MULTISAMPLE, df->multisampletextures[0].id); states_bindActiveTexture(1, GL_TEXTURE_2D_MULTISAMPLE, df->multisampletextures[1].id); states_bindActiveTexture(2, GL_TEXTURE_2D_MULTISAMPLE, df->multisampletextures[2].id); } else { states_bindActiveTexture(0, GL_TEXTURE_2D, df->textures[0].id); states_bindActiveTexture(1, GL_TEXTURE_2D, df->textures[1].id); states_bindActiveTexture(2, GL_TEXTURE_2D, df->textures[2].id); } // lighttile_addToRenderQueue(v, q, 16, 16); lights_addToRenderQueue(v, q, numsamples); // lighttile_addToRenderQueue(v, q, 64, 64); // lighttile_addToRenderQueue(v, q, 800, 600); // lighttile_addToRenderQueue(v, q, 2, 2); renderqueueRadixSort(q); renderqueueSetup(q); renderqueueDraw(q); return TRUE; }
gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data) { const gl::State &state = *data.state; // If the context has changed, pause the previous context's transform feedback and queries if (data.context != mPrevDrawContext) { if (mPrevDrawTransformFeedback != nullptr) { mPrevDrawTransformFeedback->syncPausedState(true); } for (QueryGL *prevQuery : mPrevDrawQueries) { prevQuery->pause(); } } mPrevDrawTransformFeedback = nullptr; mPrevDrawQueries.clear(); mPrevDrawContext = data.context; // Sync the current program state const gl::Program *program = state.getProgram(); const ProgramGL *programGL = GetImplAs<ProgramGL>(program); useProgram(programGL->getProgramID()); for (size_t uniformBlockIndex = 0; uniformBlockIndex < program->getActiveUniformBlockCount(); uniformBlockIndex++) { GLuint binding = program->getUniformBlockBinding(static_cast<GLuint>(uniformBlockIndex)); const OffsetBindingPointer<gl::Buffer> &uniformBuffer = data.state->getIndexedUniformBuffer(binding); if (uniformBuffer.get() != nullptr) { BufferGL *bufferGL = GetImplAs<BufferGL>(uniformBuffer.get()); if (uniformBuffer.getSize() == 0) { bindBufferBase(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID()); } else { bindBufferRange(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID(), uniformBuffer.getOffset(), uniformBuffer.getSize()); } } } const std::vector<SamplerBindingGL> &appliedSamplerUniforms = programGL->getAppliedSamplerUniforms(); for (const SamplerBindingGL &samplerUniform : appliedSamplerUniforms) { GLenum textureType = samplerUniform.textureType; for (GLuint textureUnitIndex : samplerUniform.boundTextureUnits) { const gl::Texture *texture = state.getSamplerTexture(textureUnitIndex, textureType); if (texture != nullptr) { const TextureGL *textureGL = GetImplAs<TextureGL>(texture); if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID()) { activeTexture(textureUnitIndex); bindTexture(textureType, textureGL->getTextureID()); } textureGL->syncState(textureUnitIndex, texture->getTextureState()); } else { if (mTextures[textureType][textureUnitIndex] != 0) { activeTexture(textureUnitIndex); bindTexture(textureType, 0); } } const gl::Sampler *sampler = state.getSampler(textureUnitIndex); if (sampler != nullptr) { const SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler); samplerGL->syncState(sampler->getSamplerState()); bindSampler(textureUnitIndex, samplerGL->getSamplerID()); } else { bindSampler(textureUnitIndex, 0); } } } const gl::Framebuffer *framebuffer = state.getDrawFramebuffer(); const FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer); bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferGL->getFramebufferID()); framebufferGL->syncDrawState(); // Seamless cubemaps are required for ES3 and higher contexts. setTextureCubemapSeamlessEnabled(data.clientVersion >= 3); // Set the current transform feedback state gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback(); if (transformFeedback) { TransformFeedbackGL *transformFeedbackGL = GetImplAs<TransformFeedbackGL>(transformFeedback); bindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbackGL->getTransformFeedbackID()); transformFeedbackGL->syncActiveState(transformFeedback->isActive(), transformFeedback->getPrimitiveMode()); transformFeedbackGL->syncPausedState(transformFeedback->isPaused()); mPrevDrawTransformFeedback = transformFeedbackGL; } else { bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); mPrevDrawTransformFeedback = nullptr; } // Set the current query state for (GLenum queryType : QueryTypes) { gl::Query *query = state.getActiveQuery(queryType); if (query != nullptr) { QueryGL *queryGL = GetImplAs<QueryGL>(query); queryGL->resume(); mPrevDrawQueries.insert(queryGL); } } return gl::Error(GL_NO_ERROR); }
gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data) { const gl::State &state = *data.state; const gl::Caps &caps = *data.caps; const gl::Program *program = state.getProgram(); const ProgramGL *programGL = GetImplAs<ProgramGL>(program); useProgram(programGL->getProgramID()); // TODO: Only apply textures referenced by the program. for (auto textureTypeIter = mTextures.begin(); textureTypeIter != mTextures.end(); textureTypeIter++) { GLenum textureType = textureTypeIter->first; // Determine if this texture type can exist in the source context bool validTextureType = (textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP || (textureType == GL_TEXTURE_2D_ARRAY && data.clientVersion >= 3) || (textureType == GL_TEXTURE_3D && data.clientVersion >= 3)); const std::vector<GLuint> &textureVector = textureTypeIter->second; for (size_t textureUnitIndex = 0; textureUnitIndex < textureVector.size(); textureUnitIndex++) { const gl::Texture *texture = nullptr; bool validTextureUnit = textureUnitIndex < caps.maxCombinedTextureImageUnits; if (validTextureType && validTextureUnit) { texture = state.getSamplerTexture(textureUnitIndex, textureType); } if (texture != nullptr) { const TextureGL *textureGL = GetImplAs<TextureGL>(texture); textureGL->syncSamplerState(texture->getSamplerState()); if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID()) { activeTexture(textureUnitIndex); bindTexture(textureType, textureGL->getTextureID()); } // TODO: apply sampler object if one is bound } else { if (mTextures[textureType][textureUnitIndex] != 0) { activeTexture(textureUnitIndex); bindTexture(textureType, 0); } } } } const gl::Framebuffer *framebuffer = state.getDrawFramebuffer(); const FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer); bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferGL->getFramebufferID()); setScissor(state.getScissor()); setViewport(state.getViewport()); const gl::BlendState &blendState = state.getBlendState(); setColorMask(blendState.colorMaskRed, blendState.colorMaskGreen, blendState.colorMaskBlue, blendState.colorMaskAlpha); const gl::DepthStencilState &depthStencilState = state.getDepthStencilState(); setDepthMask(depthStencilState.depthMask); setStencilMask(depthStencilState.stencilMask); return gl::Error(GL_NO_ERROR); }
/** Activates the RenderTarget by calling bindFramebuffer() and bindDrawBuffers() */ void activate(EFrameBufferBind target = FBB_FRAMEBUFFER) { bindFramebuffer(target); }