/************************************************************************************ Filename : RenderTiny_GL_Device.cpp Content : RenderDevice implementation for OpenGL (tiny version) Created : September 10, 2012 Authors : Andrew Reisse, Artem Bolgar Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ************************************************************************************/ #include "RenderTiny_GL_Device.h" #include "Kernel/OVR_Log.h" namespace OVR { namespace RenderTiny { namespace GL { static const char* StdVertexShaderSrc = "uniform mat4 Proj;\n" "uniform mat4 View;\n" "attribute vec4 Position;\n" "attribute vec4 Color;\n" "attribute vec2 TexCoord;\n" "attribute vec3 Normal;\n" "varying vec4 oColor;\n" "varying vec2 oTexCoord;\n" "varying vec3 oNormal;\n" "varying vec3 oVPos;\n" "void main()\n" "{\n" " gl_Position = Proj * (View * Position);\n" " oNormal = vec3(View * vec4(Normal,0));\n" " oVPos = vec3(View * Position);\n" " oTexCoord = TexCoord;\n" " oColor = Color;\n" "}\n"; static const char* DirectVertexShaderSrc = "uniform mat4 View;\n" "attribute vec4 Position;\n" "attribute vec4 Color;\n" "attribute vec2 TexCoord;\n" "attribute vec3 Normal;\n" "varying vec4 oColor;\n" "varying vec2 oTexCoord;\n" "varying vec3 oNormal;\n" "void main()\n" "{\n" " gl_Position = View * Position;\n" " oTexCoord = TexCoord;\n" " oColor = Color;\n" " oNormal = vec3(View * vec4(Normal,0));\n" "}\n"; static const char* SolidFragShaderSrc = "uniform vec4 Color;\n" "void main()\n" "{\n" " gl_FragColor = Color;\n" "}\n"; static const char* GouraudFragShaderSrc = "varying vec4 oColor;\n" "void main()\n" "{\n" " gl_FragColor = oColor;\n" "}\n"; static const char* TextureFragShaderSrc = "uniform sampler2D Texture0;\n" "varying vec4 oColor;\n" "varying vec2 oTexCoord;\n" "void main()\n" "{\n" " gl_FragColor = oColor * texture2D(Texture0, oTexCoord);\n" " if (gl_FragColor.a < 0.4)\n" " discard;\n" "}\n"; #define LIGHTING_COMMON \ "uniform vec3 Ambient;\n" \ "uniform vec4 LightPos[8];\n" \ "uniform vec4 LightColor[8];\n" \ "uniform float LightCount;\n" \ "varying vec4 oColor;\n" \ "varying vec2 oTexCoord;\n" \ "varying vec3 oNormal;\n" \ "varying vec3 oVPos;\n" \ "vec4 DoLight()\n" \ "{\n" \ " vec3 norm = normalize(oNormal);\n" \ " vec3 light = Ambient;\n" \ " for (int i = 0; i < int(LightCount); i++)\n" \ " {\n" \ " vec3 ltp = (LightPos[i].xyz - oVPos);\n" \ " float ldist = length(ltp);\n" \ " ltp = normalize(ltp);\n" \ " light += clamp(LightColor[i].rgb * oColor.rgb * (dot(norm, ltp) / ldist), 0.0,1.0);\n" \ " }\n" \ " return vec4(light, oColor.a);\n" \ "}\n" static const char* LitSolidFragShaderSrc = LIGHTING_COMMON "void main()\n" "{\n" " gl_FragColor = DoLight() * oColor;\n" "}\n"; static const char* LitTextureFragShaderSrc = "uniform sampler2D Texture0;\n" LIGHTING_COMMON "void main()\n" "{\n" " gl_FragColor = DoLight() * texture2D(Texture0, oTexCoord);\n" "}\n"; static const char* PostProcessVertexShaderSrc = "uniform mat4 View;\n" "uniform mat4 Texm;\n" "attribute vec4 Position;\n" "attribute vec2 TexCoord;\n" "varying vec2 oTexCoord;\n" "void main()\n" "{\n" " gl_Position = View * Position;\n" " oTexCoord = vec2(Texm * vec4(TexCoord,0,1));\n" " oTexCoord.y = 1.0-oTexCoord.y;\n" "}\n"; static const char* PostProcessFragShaderSrc = "uniform vec2 LensCenter;\n" "uniform vec2 ScreenCenter;\n" "uniform vec2 Scale;\n" "uniform vec2 ScaleIn;\n" "uniform vec4 HmdWarpParam;\n" "uniform sampler2D Texture0;\n" "varying vec2 oTexCoord;\n" "\n" "vec2 HmdWarp(vec2 in01)\n" "{\n" " vec2 theta = (in01 - LensCenter) * ScaleIn;\n" // Scales to [-1, 1] " float rSq = theta.x * theta.x + theta.y * theta.y;\n" " vec2 theta1 = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq + " " HmdWarpParam.z * rSq * rSq + HmdWarpParam.w * rSq * rSq * rSq);\n" " return LensCenter + Scale * theta1;\n" "}\n" "void main()\n" "{\n" " vec2 tc = HmdWarp(oTexCoord);\n" " if (!all(equal(clamp(tc, ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)), tc)))\n" " gl_FragColor = vec4(0);\n" " else\n" " gl_FragColor = texture2D(Texture0, tc);\n" "}\n"; // Shader with lens distortion and chromatic aberration correction. static const char* PostProcessFullFragShaderSrc = "uniform vec2 LensCenter;\n" "uniform vec2 ScreenCenter;\n" "uniform vec2 Scale;\n" "uniform vec2 ScaleIn;\n" "uniform vec4 HmdWarpParam;\n" "uniform vec4 ChromAbParam;\n" "uniform sampler2D Texture0;\n" "varying vec2 oTexCoord;\n" "\n" // Scales input texture coordinates for distortion. // ScaleIn maps texture coordinates to Scales to ([-1, 1]), although top/bottom will be // larger due to aspect ratio. "void main()\n" "{\n" " vec2 theta = (oTexCoord - LensCenter) * ScaleIn;\n" // Scales to [-1, 1] " float rSq= theta.x * theta.x + theta.y * theta.y;\n" " vec2 theta1 = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq + " " HmdWarpParam.z * rSq * rSq + HmdWarpParam.w * rSq * rSq * rSq);\n" " \n" " // Detect whether blue texture coordinates are out of range since these will scaled out the furthest.\n" " vec2 thetaBlue = theta1 * (ChromAbParam.z + ChromAbParam.w * rSq);\n" " vec2 tcBlue = LensCenter + Scale * thetaBlue;\n" " if (!all(equal(clamp(tcBlue, ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25,0.5)), tcBlue)))\n" " {\n" " gl_FragColor = vec4(0);\n" " return;\n" " }\n" " \n" " // Now do blue texture lookup.\n" " float blue = texture2D(Texture0, tcBlue).b;\n" " \n" " // Do green lookup (no scaling).\n" " vec2 tcGreen = LensCenter + Scale * theta1;\n" " vec4 center = texture2D(Texture0, tcGreen);\n" " \n" " // Do red scale and lookup.\n" " vec2 thetaRed = theta1 * (ChromAbParam.x + ChromAbParam.y * rSq);\n" " vec2 tcRed = LensCenter + Scale * thetaRed;\n" " float red = texture2D(Texture0, tcRed).r;\n" " \n" " gl_FragColor = vec4(red, center.g, blue, 1);\n" "}\n"; static const char* VShaderSrcs[VShader_Count] = { DirectVertexShaderSrc, StdVertexShaderSrc, PostProcessVertexShaderSrc }; static const char* FShaderSrcs[FShader_Count] = { SolidFragShaderSrc, GouraudFragShaderSrc, TextureFragShaderSrc, PostProcessFragShaderSrc, PostProcessFullFragShaderSrc, LitSolidFragShaderSrc, LitTextureFragShaderSrc }; RenderDevice::RenderDevice(const RendererParams& p) { for (int i = 0; i < VShader_Count; i++) VertexShaders[i] = *new Shader(this, Shader_Vertex, VShaderSrcs[i]); for (int i = 0; i < FShader_Count; i++) FragShaders[i] = *new Shader(this, Shader_Fragment, FShaderSrcs[i]); Ptr gouraudShaders = *new ShaderSet(); gouraudShaders->SetShader(VertexShaders[VShader_MVP]); gouraudShaders->SetShader(FragShaders[FShader_Gouraud]); DefaultFill = *new ShaderFill(gouraudShaders); glGenFramebuffersEXT(1, &CurrentFbo); } Shader *RenderDevice::LoadBuiltinShader(ShaderStage stage, int shader) { switch (stage) { case Shader_Vertex: return VertexShaders[shader]; case Shader_Fragment: return FragShaders[shader]; default: return NULL; } } void RenderDevice::BeginRendering() { glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glFrontFace(GL_CW); glLineWidth(3.0f); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } void RenderDevice::SetDepthMode(bool enable, bool write, CompareFunc func) { if (enable) { glEnable(GL_DEPTH_TEST); glDepthMask(write); switch (func) { case Compare_Always: glDepthFunc(GL_ALWAYS); break; case Compare_Less: glDepthFunc(GL_LESS); break; case Compare_Greater: glDepthFunc(GL_GREATER); break; default: assert(0); } } else glDisable(GL_DEPTH_TEST); } void RenderDevice::SetRealViewport(const Viewport& vp) { int wh; if (CurRenderTarget) wh = CurRenderTarget->Height; else wh = WindowHeight; glViewport(vp.x, wh-vp.y-vp.h, vp.w, vp.h); glEnable(GL_SCISSOR_TEST); glScissor(vp.x, wh-vp.y-vp.h, vp.w, vp.h); } void RenderDevice::Clear(float r, float g, float b, float a, float depth) { glClearColor(r,g,b,a); glClearDepth(depth); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } RBuffer* RenderDevice::GetDepthBuffer(int w, int h, int ms) { for (unsigned i = 0; i < DepthBuffers.GetSize(); i++) if (w == DepthBuffers[i]->Width && h == DepthBuffers[i]->Height)// && ms == DepthBuffers[i]->Samples) return DepthBuffers[i]; //Ptr newDepth = *CreateTexture(Texture_Depth|Texture_RenderTarget|ms, w, h, NULL); Ptr newDepth = *new RBuffer(GL_DEPTH24_STENCIL8, w, h); // combined depth stencil DepthBuffers.PushBack(newDepth); return newDepth.GetPtr(); } void RenderDevice::SetRenderTarget(RenderTiny::Texture* color, RenderTiny::Texture*, RenderTiny::Texture* stencil) { OVR_UNUSED(stencil); CurRenderTarget = (Texture*)color; if (color == NULL) { glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); return; } //if (depth == NULL) RBuffer* depth = GetDepthBuffer(color->GetWidth(), color->GetHeight(), 0); //CurRenderTarget->Samples); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, CurrentFbo); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, ((Texture*)color)->TexId, 0); if (depth) //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, ((Texture*)depth)->TexId, 0); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, ((RBuffer*)depth)->BufId); else glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) OVR_DEBUG_LOG(("framebuffer not complete: %x", status)); } void RenderDevice::SetWorldUniforms(const Matrix4f& proj) { Proj = proj.Transposed(); } void RenderDevice::SetTexture(RenderTiny::ShaderStage, int slot, const Texture* t) { glActiveTexture(GL_TEXTURE0 + slot); glBindTexture(GL_TEXTURE_2D, ((Texture*)t)->TexId); glActiveTexture(GL_TEXTURE0); } Buffer* RenderDevice::CreateBuffer() { return new Buffer(this); } void RenderDevice::Render(const Matrix4f& matrix, Model* model) { // Store data in buffers if not already if (!model->VertexBuffer) { Ptr vb = *CreateBuffer(); vb->Data(Buffer_Vertex, &model->Vertices[0], model->Vertices.GetSize() * sizeof(Vertex)); model->VertexBuffer = vb; } if (!model->IndexBuffer) { Ptr ib = *CreateBuffer(); ib->Data(Buffer_Index, &model->Indices[0], model->Indices.GetSize() * 2); model->IndexBuffer = ib; } Render(model->Fill ? (const ShaderFill*)model->Fill : (const ShaderFill*)DefaultFill, model->VertexBuffer, model->IndexBuffer, matrix, 0, (int)model->Indices.GetSize(), model->GetPrimType()); } void RenderDevice::Render(const ShaderFill* fill, RenderTiny::Buffer* vertices, RenderTiny::Buffer* indices, const Matrix4f& matrix, int offset, int count, PrimitiveType rprim) { ShaderSet* shaders = (ShaderSet*) ((ShaderFill*)fill)->GetShaders(); GLenum prim; switch (rprim) { case Prim_Triangles: prim = GL_TRIANGLES; break; case Prim_Lines: prim = GL_LINES; break; case Prim_TriangleStrip: prim = GL_TRIANGLE_STRIP; break; default: assert(0); return; } fill->Set(); if (shaders->ProjLoc >= 0) glUniformMatrix4fv(shaders->ProjLoc, 1, 0, &Proj.M[0][0]); if (shaders->ViewLoc >= 0) glUniformMatrix4fv(shaders->ViewLoc, 1, 0, &matrix.Transposed().M[0][0]); if (shaders->UsesLighting && Lighting->Version != shaders->LightingVer) { shaders->LightingVer = Lighting->Version; Lighting->Set(shaders); } glBindBuffer(GL_ARRAY_BUFFER, ((Buffer*)vertices)->GLBuffer); for (int i = 0; i < 4; i++) glEnableVertexAttribArray(i); glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(Vertex), (char*)offset + offsetof(Vertex, Pos)); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(Vertex), (char*)offset + offsetof(Vertex, C)); glVertexAttribPointer(2, 2, GL_FLOAT, false, sizeof(Vertex), (char*)offset + offsetof(Vertex, U)); glVertexAttribPointer(3, 3, GL_FLOAT, false, sizeof(Vertex), (char*)offset + offsetof(Vertex, Norm)); if (indices) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ((Buffer*)indices)->GLBuffer); glDrawElements(prim, count, GL_UNSIGNED_SHORT, NULL); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } else { glDrawArrays(prim, 0, count); } for (int i = 0; i < 4; i++) glDisableVertexAttribArray(i); } void RenderDevice::SetLighting(const LightingParams* lt) { Lighting = lt; } Buffer::~Buffer() { if (GLBuffer) glDeleteBuffers(1, &GLBuffer); } bool Buffer::Data(int use, const void* buffer, size_t size) { switch (use & Buffer_TypeMask) { case Buffer_Index: Use = GL_ELEMENT_ARRAY_BUFFER; break; default: Use = GL_ARRAY_BUFFER; break; } if (!GLBuffer) glGenBuffers(1, &GLBuffer); int mode = GL_DYNAMIC_DRAW; if (use & Buffer_ReadOnly) mode = GL_STATIC_DRAW; glBindBuffer(Use, GLBuffer); glBufferData(Use, size, buffer, mode); glBindBuffer(Use, 0); return 1; } void* Buffer::Map(size_t start, size_t size, int flags) { int mode = GL_WRITE_ONLY; //if (flags & Map_Unsynchronized) // mode |= GL_MAP_UNSYNCHRONIZED; glBindBuffer(Use, GLBuffer); void* v = glMapBuffer(Use, mode); glBindBuffer(Use, 0); return v; } bool Buffer::Unmap(void*) { glBindBuffer(Use, GLBuffer); int r = glUnmapBuffer(Use); glBindBuffer(Use, 0); return r; } bool Shader::Compile(const char* src) { if (!GLShader) GLShader = glCreateShader(GLStage()); glShaderSource(GLShader, 1, &src, 0); glCompileShader(GLShader); GLint r; glGetShaderiv(GLShader, GL_COMPILE_STATUS, &r); if (!r) { GLchar msg[1024]; glGetShaderInfoLog(GLShader, sizeof(msg), 0, msg); if (msg[0]) OVR_DEBUG_LOG(("Compiling shader\n%s\nfailed: %s\n", src, msg)); if (!r) return 0; } return 1; } ShaderSet::ShaderSet() { Prog = glCreateProgram(); } ShaderSet::~ShaderSet() { glDeleteProgram(Prog); } bool ShaderSet::Link() { glBindAttribLocation(Prog, 0, "Position"); glBindAttribLocation(Prog, 1, "Color"); glBindAttribLocation(Prog, 2, "TexCoord"); glBindAttribLocation(Prog, 3, "Normal"); glLinkProgram(Prog); GLint r; glGetProgramiv(Prog, GL_LINK_STATUS, &r); if (!r) { GLchar msg[1024]; glGetProgramInfoLog(Prog, sizeof(msg), 0, msg); OVR_DEBUG_LOG(("Linking shaders failed: %s\n", msg)); if (!r) return 0; } glUseProgram(Prog); UniformInfo.Clear(); LightingVer = 0; UsesLighting = 0; GLuint i = 0; for(;; i++) { GLsizei namelen; GLint size = 0; GLenum type; GLchar name[32]; glGetActiveUniform(Prog, i, sizeof(name), &namelen, &size, &type, name); if (size) { int l = glGetUniformLocation(Prog, name); char *np = name; while (*np) { if (*np == '[') *np = 0; np++; } Uniform u; u.Name = name; u.Location = l; u.Size = size; switch (type) { case GL_FLOAT: u.Type = 1; break; case GL_FLOAT_VEC2: u.Type = 2; break; case GL_FLOAT_VEC3: u.Type = 3; break; case GL_FLOAT_VEC4: u.Type = 4; break; case GL_FLOAT_MAT4: u.Type = 16; break; default: continue; } UniformInfo.PushBack(u); if (!strcmp(name, "LightCount")) UsesLighting = 1; } else break; } ProjLoc = glGetUniformLocation(Prog, "Proj"); ViewLoc = glGetUniformLocation(Prog, "View"); for (int i = 0; i < 8; i++) { char texv[32]; sprintf(texv, "Texture%d", i); TexLoc[i] = glGetUniformLocation(Prog, texv); if (TexLoc[i] < 0) break; glUniform1i(TexLoc[i], i); } if (UsesLighting) OVR_ASSERT(ProjLoc >= 0 && ViewLoc >= 0); return 1; } void ShaderSet::Set(PrimitiveType) const { glUseProgram(Prog); } bool ShaderSet::SetUniform(const char* name, int n, const float* v) { for (int i = 0; i < UniformInfo.GetSize(); i++) if (!strcmp(UniformInfo[i].Name.ToCStr(), name)) { OVR_ASSERT(UniformInfo[i].Location >= 0); glUseProgram(Prog); switch (UniformInfo[i].Type) { case 1: glUniform1fv(UniformInfo[i].Location, n, v); break; case 2: glUniform2fv(UniformInfo[i].Location, n/2, v); break; case 3: glUniform3fv(UniformInfo[i].Location, n/3, v); break; case 4: glUniform4fv(UniformInfo[i].Location, n/4, v); break; default: OVR_ASSERT(0); } return 1; } OVR_DEBUG_LOG(("Warning: uniform %s not present in selected shader", name)); return 0; } bool ShaderSet::SetUniform4x4f(const char* name, const Matrix4f& m) { for (int i = 0; i < UniformInfo.GetSize(); i++) if (!strcmp(UniformInfo[i].Name.ToCStr(), name)) { glUseProgram(Prog); glUniformMatrix4fv(UniformInfo[i].Location, 1, 1, &m.M[0][0]); return 1; } OVR_DEBUG_LOG(("Warning: uniform %s not present in selected shader", name)); return 0; } Texture::Texture(RenderDevice* r, int w, int h) : Ren(r), Width(w), Height(h) { glGenTextures(1, &TexId); } Texture::~Texture() { if (TexId) glDeleteTextures(1, &TexId); } void Texture::Set(int slot, RenderTiny::ShaderStage stage) const { Ren->SetTexture(stage, slot, this); } void Texture::SetSampleMode(int sm) { glBindTexture(GL_TEXTURE_2D, TexId); switch (sm & Sample_FilterMask) { case Sample_Linear: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0); break; case Sample_Anisotropic: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 8); break; case Sample_Nearest: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0); break; } switch (sm & Sample_AddressMask) { case Sample_Repeat: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); break; case Sample_Clamp: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); break; case Sample_ClampBorder: glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); break; } glBindTexture(GL_TEXTURE_2D, 0); } Texture* RenderDevice::CreateTexture(int format, int width, int height, const void* data, int mipcount) { GLenum glformat, gltype = GL_UNSIGNED_BYTE; switch(format & Texture_TypeMask) { case Texture_RGBA: glformat = GL_RGBA; break; case Texture_Depth: glformat = GL_DEPTH; gltype = GL_DEPTH_COMPONENT; break; default: return NULL; } Texture* NewTex = new Texture(this, width, height); glBindTexture(GL_TEXTURE_2D, NewTex->TexId); glGetError(); glTexImage2D(GL_TEXTURE_2D, 0, glformat, width, height, 0, glformat, gltype, data); OVR_ASSERT(!glGetError()); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if (format == (Texture_RGBA|Texture_GenMipmaps)) // not render target { int srcw = width, srch = height; int level = 0; UByte* mipmaps = NULL; do { level++; int mipw = srcw >> 1; if (mipw < 1) mipw = 1; int miph = srch >> 1; if (miph < 1) miph = 1; if (mipmaps == NULL) mipmaps = (UByte*)OVR_ALLOC(mipw * miph * 4); FilterRgba2x2(level == 1 ? (const UByte*)data : mipmaps, srcw, srch, mipmaps); glTexImage2D(GL_TEXTURE_2D, level, glformat, mipw, miph, 0, glformat, gltype, mipmaps); OVR_ASSERT(!glGetError()); srcw = mipw; srch = miph; } while (srcw > 1 || srch > 1); if (mipmaps) OVR_FREE(mipmaps); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level); OVR_ASSERT(!glGetError()); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipcount-1); OVR_ASSERT(!glGetError()); } OVR_ASSERT(!glGetError()); glBindTexture(GL_TEXTURE_2D, 0); return NewTex; } RBuffer::RBuffer(GLenum format, GLint w, GLint h) { Width = w; Height = h; glGenRenderbuffersEXT(1, &BufId); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, BufId); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, format, w, h); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); } RBuffer::~RBuffer() { glDeleteRenderbuffersEXT(1, &BufId); } }}}