diff --git a/ext/native/thin3d/GLQueueRunner.cpp b/ext/native/thin3d/GLQueueRunner.cpp index bdea224380..3d2167377f 100644 --- a/ext/native/thin3d/GLQueueRunner.cpp +++ b/ext/native/thin3d/GLQueueRunner.cpp @@ -2,6 +2,7 @@ #include "GLRenderManager.h" #include "base/logging.h" #include "gfx/gl_common.h" +#include "gfx/gl_debug_log.h" #include "gfx_es2/gpu_features.h" #include "math/dataconv.h" @@ -19,6 +20,21 @@ void GLQueueRunner::RunInitSteps(const std::vector &steps) { switch (step.stepType) { case GLRInitStepType::CREATE_TEXTURE: break; + case GLRInitStepType::CREATE_BUFFER: + { + GLRBuffer *buffer = step.create_buffer.buffer; + glGenBuffers(1, &buffer->buffer); + glBindBuffer(buffer->target_, buffer->buffer); + glBufferData(buffer->target_, step.create_buffer.size, nullptr, step.create_buffer.usage); + break; + } + case GLRInitStepType::BUFFER_SUBDATA: + { + GLRBuffer *buffer = step.buffer_subdata.buffer; + glBufferSubData(buffer->buffer, step.buffer_subdata.offset, step.buffer_subdata.size, step.buffer_subdata.data); + delete[] step.buffer_subdata.data; + break; + } case GLRInitStepType::CREATE_PROGRAM: { GLRProgram *program = step.create_program.program; @@ -90,12 +106,18 @@ void GLQueueRunner::RunInitSteps(const std::vector &steps) { } break; } - case GLRInitStepType::CREATE_BUFFER: - glGenBuffers(1, &step.create_buffer.buffer->buffer); - break; case GLRInitStepType::TEXTURE_SUBDATA: break; + case GLRInitStepType::TEXTURE_IMAGE: + { + GLRTexture *tex = step.texture_image.texture; + CHECK_GL_ERROR_IF_DEBUG(); + glTexImage2D(tex->target, step.texture_image.level, step.texture_image.internalFormat, step.texture_image.width, step.texture_image.height, 0, step.texture_image.format, step.texture_image.type, step.texture_image.data); + delete[] step.texture_image.data; + CHECK_GL_ERROR_IF_DEBUG(); + break; + } } } } @@ -148,7 +170,7 @@ void GLQueueRunner::PerformRenderPass(const GLRStep &step) { int curHeight = step.render.framebuffer ? step.render.framebuffer->height : 0; // vulkan_->GetBackbufferHeight(); GLRFramebuffer *fb = step.render.framebuffer; - + GLRProgram *curProgram = nullptr; GLint activeTexture = GL_TEXTURE0; auto &commands = step.commands; @@ -197,24 +219,40 @@ void GLQueueRunner::PerformRenderPass(const GLRStep &step) { glScissor(c.scissor.rc.x, c.scissor.rc.y, c.scissor.rc.w, c.scissor.rc.h); break; case GLRRenderCommand::UNIFORM4F: - switch (c.uniform4.count) { - case 1: - glUniform1f(c.uniform4.loc, c.uniform4.v[0]); - break; - case 2: - glUniform2fv(c.uniform4.loc, 1, c.uniform4.v); - break; - case 3: - glUniform3fv(c.uniform4.loc, 1, c.uniform4.v); - break; - case 4: - glUniform4fv(c.uniform4.loc, 1, c.uniform4.v); - break; + { + int loc = c.uniform4.loc; + if (c.uniform4.name) { + loc = curProgram->GetUniformLoc(c.uniform4.name); + } + if (loc >= 0) { + switch (c.uniform4.count) { + case 1: + glUniform1f(loc, c.uniform4.v[0]); + break; + case 2: + glUniform2fv(loc, 1, c.uniform4.v); + break; + case 3: + glUniform3fv(loc, 1, c.uniform4.v); + break; + case 4: + glUniform4fv(loc, 1, c.uniform4.v); + break; + } } break; + } case GLRRenderCommand::UNIFORMMATRIX: - glUniformMatrix4fv(c.uniformMatrix4.loc, 1, false, c.uniformMatrix4.m); + { + int loc = c.uniform4.loc; + if (c.uniform4.name) { + loc = curProgram->GetUniformLoc(c.uniform4.name); + } + if (loc >= 0) { + glUniformMatrix4fv(loc, 1, false, c.uniformMatrix4.m); + } break; + } case GLRRenderCommand::STENCIL: glStencilFunc(c.stencil.func, c.stencil.ref, c.stencil.compareMask); glStencilOp(c.stencil.sFail, c.stencil.zFail, c.stencil.pass); @@ -227,14 +265,18 @@ void GLQueueRunner::PerformRenderPass(const GLRStep &step) { glActiveTexture(target); activeTexture = target; } - glBindTexture(GL_TEXTURE_2D, c.texture.texture->texture); + glBindTexture(c.texture.texture->target, c.texture.texture->texture); break; } case GLRRenderCommand::BINDPROGRAM: { glUseProgram(c.program.program->program); + curProgram = c.program.program; break; } + case GLRRenderCommand::GENMIPS: + glGenerateMipmap(GL_TEXTURE_2D); + break; case GLRRenderCommand::DRAW: glDrawArrays(c.draw.mode, c.draw.first, c.draw.count); break; @@ -243,6 +285,12 @@ void GLQueueRunner::PerformRenderPass(const GLRStep &step) { glDrawElements(c.drawIndexed.mode, c.drawIndexed.count, c.drawIndexed.indexType, c.drawIndexed.indices); } break; + case GLRRenderCommand::TEXTURESAMPLER: + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, c.textureSampler.wrapS); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, c.textureSampler.wrapT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, c.textureSampler.magFilter); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, c.textureSampler.minFilter); + break; } } if (activeTexture != GL_TEXTURE0) diff --git a/ext/native/thin3d/GLQueueRunner.h b/ext/native/thin3d/GLQueueRunner.h index e16ada4562..e953e840a7 100644 --- a/ext/native/thin3d/GLQueueRunner.h +++ b/ext/native/thin3d/GLQueueRunner.h @@ -35,6 +35,7 @@ enum class GLRRenderCommand : uint8_t { CLEAR, BINDPROGRAM, BINDTEXTURE, + GENMIPS, DRAW, DRAW_INDEXED, PUSH_CONSTANTS, @@ -85,11 +86,13 @@ struct GLRRenderData { void *indices; } drawIndexed; struct { + const char *name; // if null, use loc GLint loc; GLint count; float v[4]; } uniform4; struct { + const char *name; // if null, use loc GLint loc; float m[16]; } uniformMatrix4; @@ -107,11 +110,10 @@ struct GLRRenderData { GLRProgram *program; } program; struct { - GLuint wrapU; - GLuint wrapV; - bool maxFilter; - bool minFilter; - bool mipFilter; + GLenum wrapS; + GLenum wrapT; + GLenum magFilter; + GLenum minFilter; // also includes mip. GL... } textureSampler; struct { GLRViewport vp; @@ -136,6 +138,7 @@ enum class GLRInitStepType : uint8_t { CREATE_PROGRAM, CREATE_BUFFER, + TEXTURE_IMAGE, TEXTURE_SUBDATA, BUFFER_SUBDATA, }; @@ -151,6 +154,7 @@ struct GLRInitStep { union { struct { GLRTexture *texture; + GLenum target; int width; int height; // ... @@ -167,7 +171,25 @@ struct GLRInitStep { } create_program; struct { GLRBuffer *buffer; + int size; + GLuint usage; } create_buffer; + struct { + GLRBuffer *buffer; + int offset; + int size; + uint8_t *data; // owned, delete[]-d + } buffer_subdata; + struct { + GLRTexture *texture; + GLenum internalFormat; + GLenum format; + GLenum type; + int level; + int width; + int height; + uint8_t *data; // owned, delete[]-d + } texture_image; }; }; diff --git a/ext/native/thin3d/GLRenderManager.h b/ext/native/thin3d/GLRenderManager.h index c44246c604..a48103b539 100644 --- a/ext/native/thin3d/GLRenderManager.h +++ b/ext/native/thin3d/GLRenderManager.h @@ -1,6 +1,8 @@ #pragma once #include +#include +#include #include #include @@ -81,6 +83,26 @@ public: }; GLuint program = 0; std::vector semantics_; + + struct UniformInfo { + int loc_; + }; + + // Must ONLY be called from GLQueueRunner! + int GetUniformLoc(const char *name) { + auto iter = uniformCache_.find(name); + int loc = -1; + if (iter != uniformCache_.end()) { + loc = iter->second.loc_; + } else { + loc = glGetUniformLocation(program, name); + UniformInfo info; + info.loc_ = loc; + uniformCache_[name] = info; + } + return loc; + } + std::map uniformCache_; }; class GLRTexture { @@ -91,16 +113,20 @@ public: } } GLuint texture; + GLenum target; }; class GLRBuffer { public: + GLRBuffer(GLuint target) : target_(target) {} ~GLRBuffer() { if (buffer) { glDeleteBuffers(1, &buffer); } } GLuint buffer; + GLuint target_; +private: }; enum class GLRRunType { @@ -119,6 +145,8 @@ public: std::vector shaders; std::vector programs; + std::vector buffers; + std::vector textures; }; @@ -139,15 +167,23 @@ public: void Wipe(); // Creation commands. These were not needed in Vulkan since there we can do that on the main thread. - GLRTexture *CreateTexture(int w, int h) { + GLRTexture *CreateTexture(GLenum target, int w, int h) { GLRInitStep step{ GLRInitStepType::CREATE_TEXTURE }; step.create_texture.texture = new GLRTexture(); + step.create_texture.texture->target = target; step.create_texture.width = w; step.create_texture.height = h; initSteps_.push_back(step); return step.create_texture.texture; } + GLRBuffer *CreateBuffer(GLuint target, int size, GLuint usage) { + GLRInitStep step{ GLRInitStepType::CREATE_BUFFER }; + step.create_buffer.buffer = new GLRBuffer(target); + initSteps_.push_back(step); + return step.create_buffer.buffer; + } + GLRShader *CreateShader(GLuint stage, std::string &code) { GLRInitStep step{ GLRInitStepType::CREATE_SHADER }; step.create_shader.shader = new GLRShader(); @@ -176,6 +212,12 @@ public: void DeleteProgram(GLRProgram *program) { deleter_.programs.push_back(program); } + void DeleteBuffer(GLRBuffer *buffer) { + deleter_.buffers.push_back(buffer); + } + void DeleteTexture(GLRTexture *texture) { + deleter_.textures.push_back(texture); + } void BindFramebufferAsRenderTarget(GLRFramebuffer *fb, GLRRenderPassAction color, GLRRenderPassAction depth, uint32_t clearColor, float clearDepth, uint8_t clearStencil); GLuint BindFramebufferAsTexture(GLRFramebuffer *fb, int binding, int aspectBit, int attachment); @@ -185,6 +227,38 @@ public: void CopyFramebuffer(GLRFramebuffer *src, GLRect2D srcRect, GLRFramebuffer *dst, GLOffset2D dstPos, int aspectMask); void BlitFramebuffer(GLRFramebuffer *src, GLRect2D srcRect, GLRFramebuffer *dst, GLRect2D dstRect, int aspectMask, bool filter); + // Takes ownership of data. + void BufferSubdata(GLRBuffer *buffer, int offset, int size, uint8_t *data) { + // TODO: Maybe should be a render command instead of an init command? When possible it's better as + // an init command, that's for sure. + GLRInitStep step{ GLRInitStepType::BUFFER_SUBDATA }; + step.buffer_subdata.buffer = buffer; + step.buffer_subdata.offset = offset; + step.buffer_subdata.size = size; + step.buffer_subdata.data = data; + initSteps_.push_back(step); + } + + void TextureImage(GLRTexture *texture, int level, int width, int height, GLenum internalFormat, GLenum format, GLenum type, uint8_t *data) { + GLRInitStep step{ GLRInitStepType::TEXTURE_IMAGE }; + step.texture_image.data = data; + step.texture_image.internalFormat = internalFormat; + step.texture_image.format = format; + step.texture_image.type = type; + step.texture_image.level = level; + step.texture_image.width = width; + step.texture_image.height = height; + initSteps_.push_back(step); + } + + void BindTexture(int slot, GLRTexture *tex) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::BINDTEXTURE }; + data.texture.slot = slot; + data.texture.texture = tex; + curRenderStep_->commands.push_back(data); + } + void BindProgram(GLRProgram *program) { _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); GLRRenderData data{ GLRRenderCommand::BINDPROGRAM }; @@ -192,6 +266,12 @@ public: curRenderStep_->commands.push_back(data); } + void GenerateMipmap() { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::GENMIPS }; + curRenderStep_->commands.push_back(data); + } + void SetDepth(bool enabled, bool write, GLenum func) { _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); GLRRenderData data{ GLRRenderCommand::DEPTH }; @@ -215,6 +295,40 @@ public: curRenderStep_->commands.push_back(data); } + void SetUniformF(int loc, int count, const float *udata) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::UNIFORM4F }; + data.uniform4.loc = loc; + data.uniform4.count = count; + memcpy(data.uniform4.v, udata, sizeof(float) * count); + curRenderStep_->commands.push_back(data); + } + + void SetUniformF(const char *name, int count, const float *udata) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::UNIFORM4F }; + data.uniform4.name = name; + data.uniform4.count = count; + memcpy(data.uniform4.v, udata, sizeof(float) * count); + curRenderStep_->commands.push_back(data); + } + + void SetUniformM4x4(int loc, const float *udata) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::UNIFORM4F }; + data.uniformMatrix4.loc = loc; + memcpy(data.uniformMatrix4.m, udata, sizeof(float) * 16); + curRenderStep_->commands.push_back(data); + } + + void SetUniformM4x4(const char *name, const float *udata) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::UNIFORM4F }; + data.uniformMatrix4.name = name; + memcpy(data.uniformMatrix4.m, udata, sizeof(float) * 16); + curRenderStep_->commands.push_back(data); + } + void SetStencil(bool enabled, GLenum func, GLenum sFail, GLenum zFail, GLenum pass, uint8_t writeMask, uint8_t compareMask, uint8_t refValue) { _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); GLRRenderData data{ GLRRenderCommand::STENCIL }; @@ -243,6 +357,17 @@ public: data.raster.cullFace = cullFace; curRenderStep_->commands.push_back(data); } + + // Modifies the current texture as per GL specs, not global state. + void SetTextureSampler(GLenum wrapS, GLenum wrapT, GLenum magFilter, GLenum minFilter) { + _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); + GLRRenderData data{ GLRRenderCommand::TEXTURESAMPLER }; + data.textureSampler.wrapS = wrapS; + data.textureSampler.wrapT = wrapT; + data.textureSampler.magFilter = magFilter; + data.textureSampler.minFilter = minFilter; + curRenderStep_->commands.push_back(data); + } void Clear(uint32_t clearColor, float clearZ, int clearStencil, int clearMask) { _dbg_assert_(G3D, curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER); diff --git a/ext/native/thin3d/thin3d.h b/ext/native/thin3d/thin3d.h index b401a6268f..6bbc0d50e8 100644 --- a/ext/native/thin3d/thin3d.h +++ b/ext/native/thin3d/thin3d.h @@ -587,7 +587,10 @@ public: // color must be 0, for now. virtual void BindFramebufferAsTexture(Framebuffer *fbo, int binding, FBChannel channelBit, int attachment) = 0; - virtual uintptr_t GetFramebufferAPITexture(Framebuffer *fbo, int channelBits, int attachment) = 0; + // deprecated + virtual uintptr_t GetFramebufferAPITexture(Framebuffer *fbo, int channelBits, int attachment) { + return 0; + } virtual void GetFramebufferDimensions(Framebuffer *fbo, int *w, int *h) = 0; diff --git a/ext/native/thin3d/thin3d_gl.cpp b/ext/native/thin3d/thin3d_gl.cpp index 6d1635723e..b247ca0b96 100644 --- a/ext/native/thin3d/thin3d_gl.cpp +++ b/ext/native/thin3d/thin3d_gl.cpp @@ -312,10 +312,6 @@ public: intptr_t lastBase_; }; -struct UniformInfo { - int loc_; -}; - class OpenGLPipeline : public Pipeline { public: OpenGLPipeline(GLRenderManager *render) : render_(render) { @@ -352,7 +348,6 @@ public: GLRProgram *program_ = nullptr; private: GLRenderManager *render_; - std::map uniformCache_; }; class OpenGLFramebuffer; @@ -398,8 +393,6 @@ public: // color must be 0, for now. void BindFramebufferAsTexture(Framebuffer *fbo, int binding, FBChannel channelBit, int attachment) override; - uintptr_t GetFramebufferAPITexture(Framebuffer *fbo, int channelBits, int attachment) override; - void GetFramebufferDimensions(Framebuffer *fbo, int *w, int *h) override; void BindSamplerStates(int start, int count, SamplerState **states) override { @@ -422,17 +415,12 @@ public: } void SetViewports(int count, Viewport *viewports) override { - // TODO: Use glViewportArrayv. - glViewport((GLint)viewports[0].TopLeftX, (GLint)viewports[0].TopLeftY, (GLsizei)viewports[0].Width, (GLsizei)viewports[0].Height); -#if defined(USING_GLES2) - glDepthRangef(viewports[0].MinDepth, viewports[0].MaxDepth); -#else - glDepthRange(viewports[0].MinDepth, viewports[0].MaxDepth); -#endif + // Same structure, different name. + renderManager_.SetViewport((GLRViewport &)*viewports); } void SetBlendFactor(float color[4]) override { - glBlendColor(color[0], color[1], color[2], color[3]); + renderManager_.SetBlendFactor(color); } void BindTextures(int start, int count, Texture **textures) override; @@ -585,7 +573,7 @@ inline bool isPowerOf2(int n) { class OpenGLTexture : public Texture { public: - OpenGLTexture(const TextureDesc &desc); + OpenGLTexture(GLRenderManager *render, const TextureDesc &desc); ~OpenGLTexture(); bool HasMips() const { @@ -595,8 +583,8 @@ public: return canWrap_; } TextureType GetType() const { return type_; } - void Bind() { - glBindTexture(target_, tex_); + void Bind(int stage) { + render_->BindTexture(stage, tex_); } void AutoGenMipmaps(); @@ -604,8 +592,8 @@ public: private: void SetImageData(int x, int y, int z, int width, int height, int depth, int level, int stride, const uint8_t *data); - GLuint tex_ = 0; - GLuint target_ = 0; + GLRenderManager *render_; + GLRTexture *tex_; DataFormat format_; TextureType type_; @@ -614,7 +602,7 @@ private: bool canWrap_; }; -OpenGLTexture::OpenGLTexture(const TextureDesc &desc) { +OpenGLTexture::OpenGLTexture(GLRenderManager *render, const TextureDesc &desc) : render_(render) { generatedMips_ = false; canWrap_ = true; width_ = desc.width; @@ -622,16 +610,16 @@ OpenGLTexture::OpenGLTexture(const TextureDesc &desc) { depth_ = desc.depth; format_ = desc.format; type_ = desc.type; - target_ = TypeToTarget(desc.type); + GLenum target = TypeToTarget(desc.type); + tex_ = render->CreateTexture(target, width_, height_); + + render->BindTexture(0, tex_); + canWrap_ = isPowerOf2(width_) && isPowerOf2(height_); mipLevels_ = desc.mipLevels; if (!desc.initData.size()) return; - glActiveTexture(GL_TEXTURE0 + 0); - glGenTextures(1, &tex_); - glBindTexture(target_, tex_); - int level = 0; for (auto data : desc.initData) { SetImageData(0, 0, 0, width_, height_, depth_, level, 0, data); @@ -641,6 +629,8 @@ OpenGLTexture::OpenGLTexture(const TextureDesc &desc) { } mipLevels_ = desc.generateMips ? desc.mipLevels : level; + render->SetTextureSampler(GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_LINEAR, mipLevels_ > 1 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); + /* #ifdef USING_GLES2 if (gl_extensions.GLES3) { glTexParameteri(target_, GL_TEXTURE_MAX_LEVEL, mipLevels_ - 1); @@ -648,8 +638,7 @@ OpenGLTexture::OpenGLTexture(const TextureDesc &desc) { #else glTexParameteri(target_, GL_TEXTURE_MAX_LEVEL, mipLevels_ - 1); #endif - glTexParameteri(target_, GL_TEXTURE_MIN_FILTER, mipLevels_ > 1 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); - glTexParameteri(target_, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +*/ if ((int)desc.initData.size() < desc.mipLevels && desc.generateMips) { ILOG("Generating mipmaps"); @@ -657,12 +646,12 @@ OpenGLTexture::OpenGLTexture(const TextureDesc &desc) { } // Unbind. - glBindTexture(target_, 0); + render->BindTexture(0, nullptr); } OpenGLTexture::~OpenGLTexture() { if (tex_) { - glDeleteTextures(1, &tex_); + render_->DeleteTexture(tex_); tex_ = 0; generatedMips_ = false; } @@ -670,8 +659,8 @@ OpenGLTexture::~OpenGLTexture() { void OpenGLTexture::AutoGenMipmaps() { if (!generatedMips_) { - glBindTexture(target_, tex_); - glGenerateMipmap(target_); + render_->BindTexture(0, tex_); + render_->GenerateMipmap(); generatedMips_ = true; } } @@ -681,6 +670,8 @@ public: OpenGLFramebuffer() {} ~OpenGLFramebuffer(); + GLRFramebuffer *framebuffer; + GLuint handle = 0; GLuint color_texture = 0; GLuint z_stencil_buffer = 0; // Either this is set, or the two below. @@ -792,16 +783,12 @@ void OpenGLTexture::SetImageData(int x, int y, int z, int width, int height, int return; } - CHECK_GL_ERROR_IF_DEBUG(); - switch (target_) { - case GL_TEXTURE_2D: - glTexImage2D(GL_TEXTURE_2D, level, internalFormat, width_, height_, 0, format, type, data); - break; - default: - ELOG("Thin3D GL: Targets other than GL_TEXTURE_2D not yet supported"); - break; + // Make a copy of data with stride eliminated. + uint8_t *texData = new uint8_t[width * height * alignment]; + for (int y = 0; y < height; y++) { + memcpy(texData + y * width * alignment, data + y * stride * alignment, width * alignment); } - CHECK_GL_ERROR_IF_DEBUG(); + render_->TextureImage(tex_, level, width, height, internalFormat, format, type, texData); } @@ -879,7 +866,7 @@ bool OpenGLContext::CopyFramebufferToMemorySync(Framebuffer *src, int channelBit Texture *OpenGLContext::CreateTexture(const TextureDesc &desc) { - return new OpenGLTexture(desc); + return new OpenGLTexture(&renderManager_, desc); } OpenGLInputLayout::~OpenGLInputLayout() { @@ -978,28 +965,29 @@ RasterState *OpenGLContext::CreateRasterState(const RasterStateDesc &desc) { class OpenGLBuffer : public Buffer { public: - OpenGLBuffer(size_t size, uint32_t flags) { - glGenBuffers(1, &buffer_); + OpenGLBuffer(GLRenderManager *render, size_t size, uint32_t flags) : render_(render) { target_ = (flags & BufferUsageFlag::INDEXDATA) ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER; usage_ = 0; if (flags & BufferUsageFlag::DYNAMIC) usage_ = GL_STREAM_DRAW; else usage_ = GL_STATIC_DRAW; + buffer_ = render->CreateBuffer(target_, size, usage_); totalSize_ = size; - glBindBuffer(target_, buffer_); - glBufferData(target_, size, NULL, usage_); } ~OpenGLBuffer() override { - glDeleteBuffers(1, &buffer_); + render_->DeleteBuffer(buffer_); } void Bind(int offset) { + Crash(); + // render_->BindBuffer(buffer_); // TODO: Can't support offset using ES 2.0 - glBindBuffer(target_, buffer_); + // glBindBuffer(target_, buffer_); } - GLuint buffer_; + GLRenderManager *render_; + GLRBuffer *buffer_; GLuint target_; GLuint usage_; @@ -1007,7 +995,7 @@ public: }; Buffer *OpenGLContext::CreateBuffer(size_t size, uint32_t usageFlags) { - return new OpenGLBuffer(size, usageFlags); + return new OpenGLBuffer(&renderManager_, size, usageFlags); } void OpenGLContext::UpdateBuffer(Buffer *buffer, const uint8_t *data, size_t offset, size_t size, UpdateBufferFlags flags) { @@ -1017,14 +1005,17 @@ void OpenGLContext::UpdateBuffer(Buffer *buffer, const uint8_t *data, size_t off if (size + offset > buf->totalSize_) { Crash(); } + + uint8_t *dataCopy = new uint8_t[size]; + memcpy(dataCopy, data, size); // if (flags & UPDATE_DISCARD) we could try to orphan the buffer using glBufferData. - glBufferSubData(buf->target_, offset, size, data); + renderManager_.BufferSubdata(buf->buffer_, offset, size, dataCopy); } Pipeline *OpenGLContext::CreateGraphicsPipeline(const PipelineDesc &desc) { if (!desc.shaders.size()) { ELOG("Pipeline requires at least one shader"); - return NULL; + return nullptr; } OpenGLPipeline *pipeline = new OpenGLPipeline(&renderManager_); for (auto iter : desc.shaders) { @@ -1056,16 +1047,14 @@ void OpenGLContext::BindTextures(int start, int count, Texture **textures) { maxTextures_ = std::max(maxTextures_, start + count); for (int i = start; i < start + count; i++) { OpenGLTexture *glTex = static_cast(textures[i]); - glActiveTexture(GL_TEXTURE0 + i); if (!glTex) { boundTextures_[i] = 0; - glBindTexture(GL_TEXTURE_2D, 0); + renderManager_.BindTexture(i, nullptr); continue; } - glTex->Bind(); + glTex->Bind(i); boundTextures_[i] = glTex; } - glActiveTexture(GL_TEXTURE0); } void OpenGLContext::ApplySamplers() { @@ -1075,24 +1064,18 @@ void OpenGLContext::ApplySamplers() { const OpenGLTexture *tex = boundTextures_[i]; if (!tex) continue; + GLenum wrapS; + GLenum wrapT; if (tex->CanWrap()) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, samp->wrapU); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, samp->wrapV); -#ifndef USING_GLES2 - if (tex->GetType() == TextureType::LINEAR3D) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, samp->wrapW); -#endif + wrapS = samp->wrapU; + wrapT = samp->wrapV; } else { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - } - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, samp->magFilt); - if (tex->HasMips()) { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, samp->mipMinFilt); - } else { - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, samp->minFilt); + wrapS = GL_CLAMP_TO_EDGE; + wrapT = GL_CLAMP_TO_EDGE; } + GLenum magFilt = samp->magFilt; + GLenum minFilt = tex->HasMips() ? samp->mipMinFilt : samp->minFilt; + renderManager_.SetTextureSampler(wrapS, wrapT, magFilt, minFilt); } } } @@ -1113,7 +1096,6 @@ bool OpenGLPipeline::LinkShaders() { linkShaders.push_back(iter->GetShader()); } std::vector semantics; - semantics.push_back({ SEM_POSITION, "Position" }); // Bind all the common vertex data points. Mismatching ones will be ignored. semantics.push_back({ SEM_POSITION, "Position" }); semantics.push_back({ SEM_COLOR0, "Color0" }); @@ -1125,21 +1107,6 @@ bool OpenGLPipeline::LinkShaders() { return true; } -int OpenGLPipeline::GetUniformLoc(const char *name) { - auto iter = uniformCache_.find(name); - int loc = -1; - if (iter != uniformCache_.end()) { - loc = iter->second.loc_; - } else { - Crash(); - // loc = glGetUniformLocation(program_, name); - UniformInfo info; - info.loc_ = loc; - uniformCache_[name] = info; - } - return loc; -} - void OpenGLContext::BindPipeline(Pipeline *pipeline) { curPipeline_ = (OpenGLPipeline *)pipeline; curPipeline_->blend->Apply(&renderManager_); @@ -1154,16 +1121,13 @@ void OpenGLContext::UpdateDynamicUniformBuffer(const void *ub, size_t size) { } for (auto &uniform : curPipeline_->dynamicUniforms.uniforms) { - GLuint loc = curPipeline_->GetUniformLoc(uniform.name); - if (loc == -1) - Crash(); const float *data = (const float *)((uint8_t *)ub + uniform.offset); switch (uniform.type) { case UniformType::FLOAT4: - glUniform1fv(loc, 4, data); + renderManager_.SetUniformF(uniform.name, 4, data); break; case UniformType::MATRIX4X4: - glUniformMatrix4fv(loc, 1, false, data); + renderManager_.SetUniformM4x4(uniform.name, data); break; } } @@ -1612,42 +1576,17 @@ void OpenGLContext::BindFramebufferAsRenderTarget(Framebuffer *fbo, const Render void OpenGLContext::CopyFramebufferImage(Framebuffer *fbsrc, int srcLevel, int srcX, int srcY, int srcZ, Framebuffer *fbdst, int dstLevel, int dstX, int dstY, int dstZ, int width, int height, int depth, int channelBits) { OpenGLFramebuffer *src = (OpenGLFramebuffer *)fbsrc; OpenGLFramebuffer *dst = (OpenGLFramebuffer *)fbdst; - GLuint srcTex = 0; - GLuint dstTex = 0; - GLuint target = GL_TEXTURE_2D; - switch (channelBits) { - case FB_COLOR_BIT: - srcTex = src->color_texture; - dstTex = dst->color_texture; - break; - case FB_DEPTH_BIT: - target = GL_RENDERBUFFER; - srcTex = src->z_buffer ? src->z_buffer : src->z_stencil_buffer; - dstTex = dst->z_buffer ? dst->z_buffer : dst->z_stencil_buffer; - break; + + int aspect = 0; + if (channelBits & FB_COLOR_BIT) { + aspect |= GLR_ASPECT_COLOR; + } else if (channelBits & (FB_STENCIL_BIT | FB_DEPTH_BIT)) { + if (channelBits & FB_STENCIL_BIT) + aspect |= GLR_ASPECT_STENCIL; + if (channelBits & FB_DEPTH_BIT) + aspect |= GLR_ASPECT_DEPTH; } -#if defined(USING_GLES2) -#ifndef IOS - glCopyImageSubDataOES( - srcTex, target, srcLevel, srcX, srcY, srcZ, - dstTex, target, dstLevel, dstX, dstY, dstZ, - width, height, depth); -#endif -#else - if (gl_extensions.ARB_copy_image) { - glCopyImageSubData( - srcTex, target, srcLevel, srcX, srcY, srcZ, - dstTex, target, dstLevel, dstX, dstY, dstZ, - width, height, depth); - } else if (gl_extensions.NV_copy_image) { - // Older, pre GL 4.x NVIDIA cards. - glCopyImageSubDataNV( - srcTex, target, srcLevel, srcX, srcY, srcZ, - dstTex, target, dstLevel, dstX, dstY, dstZ, - width, height, depth); - } -#endif - CHECK_GL_ERROR_IF_DEBUG(); + renderManager_.CopyFramebuffer(src->framebuffer, GLRect2D{ srcX, srcY, width, height }, dst->framebuffer, GLOffset2D{ dstX, dstY }, aspect); } bool OpenGLContext::BlitFramebuffer(Framebuffer *fbsrc, int srcX1, int srcY1, int srcX2, int srcY2, Framebuffer *fbdst, int dstX1, int dstY1, int dstX2, int dstY2, int channels, FBBlitFilter linearFilter) { @@ -1679,16 +1618,6 @@ bool OpenGLContext::BlitFramebuffer(Framebuffer *fbsrc, int srcX1, int srcY1, in } } -uintptr_t OpenGLContext::GetFramebufferAPITexture(Framebuffer *fbo, int channelBits, int attachment) { - OpenGLFramebuffer *fb = (OpenGLFramebuffer *)fbo; - switch (channelBits) { - case FB_COLOR_BIT: return (uintptr_t)fb->color_texture; - case FB_DEPTH_BIT: return (uintptr_t)(fb->z_buffer ? fb->z_buffer : fb->z_stencil_buffer); - default: - return 0; - } -} - void OpenGLContext::BindFramebufferAsTexture(Framebuffer *fbo, int binding, FBChannel channelBit, int color) { OpenGLFramebuffer *fb = (OpenGLFramebuffer *)fbo; if (!fb)