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