void GLTexture::TexImage2D(GLenum int_format, int2 size, GLenum format, GLenum type, const void *data) { m_format = int_format; if (!m_texname) { glGenTextures(1, &m_texname); } else { gpuMemoryUsed -= m_texsize.x * m_texsize.y * textureFormatBytesPerPixel(m_format); } glBindTexture(GL_TEXTURE_2D, m_texname); #if OPENGL_ES m_texsize = float2(roundUpPower2(size.x), roundUpPower2(size.y)); glTexImage2D(GL_TEXTURE_2D, 0, format, m_texsize.x, m_texsize.y, 0, format, GL_UNSIGNED_BYTE, data); glReportError(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); #else m_texsize = float2(size); glTexImage2D(GL_TEXTURE_2D, 0, m_format, size.x, size.y, 0, format, type, data); glReportError(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE_SGIS); #endif glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glBindTexture(GL_TEXTURE_2D, 0); m_size = float2(size); gpuMemoryUsed += m_texsize.x * m_texsize.y * textureFormatBytesPerPixel(m_format); }
void ShaderProgramBase::UseProgramBase(const ShaderState& ss) const { ASSERT_MAIN_THREAD(); ASSERTF(isLoaded(), "%s", m_name.c_str()); glReportError(); glUseProgram(m_programHandle); glUniformMatrix4fv(m_transformUniform, 1, GL_FALSE, &ss.uTransform[0][0]); glReportError(); }
const GLTexture &getDitherTex() { static GLTexture *tex = NULL; if (!tex) { static const char pattern[] = { 0, 32, 8, 40, 2, 34, 10, 42, /* 8x8 Bayer ordered dithering */ 48, 16, 56, 24, 50, 18, 58, 26, /* pattern. Each input pixel */ 12, 44, 4, 36, 14, 46, 6, 38, /* is scaled to the 0..63 range */ 60, 28, 52, 20, 62, 30, 54, 22, /* before looking in this table */ 3, 35, 11, 43, 1, 33, 9, 41, /* to determine the action. */ 51, 19, 59, 27, 49, 17, 57, 25, 15, 47, 7, 39, 13, 45, 5, 37, 63, 31, 55, 23, 61, 29, 53, 21 }; GLuint name = 0; glGenTextures(1, &name); glBindTexture(GL_TEXTURE_2D, name); 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_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 8, 8, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, pattern); glReportError(); tex = new GLTexture(name, float2(8.f), GL_LUMINANCE); } return *tex; }
void ShaderState::DrawElements(uint dt, size_t ic, const uint* i) const { ASSERT_MAIN_THREAD(); glDrawElements(dt, (GLsizei) ic, GL_UNSIGNED_INT, i); glReportError(); graphicsDrawCount++; }
void ShaderState::DrawArrays(uint dt, size_t count) const { ASSERT_MAIN_THREAD(); glDrawArrays(dt, 0, (GLsizei)count); glReportError(); graphicsDrawCount++; }
bool GLTexture::loadFile(const char* fname) { clear(); OutlawImage image = OL_LoadImage(fname); if (!image.data) return false; glGenTextures(1, &m_texname); glBindTexture(GL_TEXTURE_2D, m_texname); //glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, image.format, image.type, image.data); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glGenerateMipmap(GL_TEXTURE_2D); glReportError(); OL_FreeImage(&image); m_size.x = image.width; m_size.y = image.height; m_texsize = m_size; m_format = GL_RGBA; return true; }
void View::setWorldLineWidth() const { const float width = getWorldPointSizeInPixels(); const float pointSize = sizePixels.x / sizePoints.x; const float lineWidth = clamp(width, 0.1f, 1.5f * pointSize); glLineWidth(lineWidth); glReportError(); }
void View::setScreenLineWidth(float scl) const { const float width = getScreenPointSizeInPixels(); const float pointSize = sizePixels.x / sizePoints.x; const float lineWidth = clamp(width, 0.1f, 1.5f * pointSize); glLineWidth(lineWidth * scl); glReportError(); }
GLint ShaderProgramBase::getUniformLocation(const char *name) const { if (!isLoaded()) return -1; GLint v = glGetUniformLocation(m_programHandle, name); ASSERTF(v >= 0, "%s::%s", m_name.c_str(), name); glReportError(); return v; }
void GLTexture::DrawFSEnd() const { glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); #if !OPENGL_ES glEnable(GL_ALPHA_TEST); #endif glReportError(); }
void GLTexture::GenerateMipmap() { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_texname); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glGenerateMipmap(GL_TEXTURE_2D); glReportError(); }
void ShaderProgramBase::UseProgramBase(const ShaderState& ss, uint size, const float2* pos) const { UseProgramBase(ss); if (m_positionSlot >= 0) { glEnableVertexAttribArray(m_positionSlot); vap1(m_positionSlot, size, pos); glReportError(); } }
void GLRenderTexture::UnbindFramebuffer() const { ASSERT(s_bound.size() && s_bound.back() == this); s_bound.pop_back(); if (s_bound.size()) { s_bound.back()->RebindFramebuffer(); } else { glReportFramebufferError(); if (s_defaultFramebuffer >= 0) { glBindFramebuffer(GL_FRAMEBUFFER, s_defaultFramebuffer); glReportError(); glReportFramebufferError(); glViewport(0, 0, globals.windowSizePixels.x, globals.windowSizePixels.y); glReportError(); } } }
void GLRenderTexture::BindFramebuffer(float2 size, ZFlags zflags) { ASSERT(!isZero(size)); if (size != m_size || ((zflags&HASZ) && !(m_zflags&HASZ))) clear(); m_size = size; m_zflags = zflags; if (!m_fbname) Generate(zflags); RebindFramebuffer(); #if !OPENGL_ES const GLint def = s_bound.size() ? s_bound.back()->m_fbname : s_defaultFramebuffer; if ((zflags == KEEPZ) && HAS_BLIT_FRAMEBUFFER && def >= 0) { ASSERT(def != m_fbname); const float2 lastSize = s_bound.size() ? s_bound.back()->m_size : globals.windowSizePixels; ASSERT(lastSize.x > 0.f && lastSize.y > 0.f); glBindFramebuffer(GL_READ_FRAMEBUFFER, def); glReportError(); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbname); glReportError(); // only GL_NEAREST is supported for depth buffers glBlitFramebuffer(0, 0, lastSize.x, lastSize.y, 0, 0, m_size.x, m_size.y, GL_DEPTH_BUFFER_BIT, GL_NEAREST); glReportError(); } else #endif if (zflags&HASZ) { glClear(GL_DEPTH_BUFFER_BIT); glReportError(); } ASSERT(s_bound.empty() || s_bound.back() != this); s_bound.push_back(this); }
void GLRenderTexture::RebindFramebuffer() { ASSERT(m_size.x >= 1 && m_size.y >= 1); ASSERT(m_fbname && m_texname); BindTexture(0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, 0); glBindFramebuffer(GL_FRAMEBUFFER, m_fbname); glReportFramebufferError(); glViewport(0,0,m_size.x,m_size.y); glReportError(); }
bool GLTexture::writeFile(const char *fname) const { const int2 sz = ceil_int(m_texsize); const size_t size = sz.x * sz.y * 4; uint *pix = (uint*) malloc(size); OutlawImage img = {}; img.width = sz.x; img.height = sz.y; img.format = GL_RGBA; img.type = GL_UNSIGNED_BYTE; img.data = (char*) pix; BindTexture(0); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix); glReportError(); invert_image(pix, sz.x, sz.y); const int success = OL_SaveImage(&img, fname); free(pix); return success; }
void pwTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); glReportError("glTexImage2D"); }
GLint pwuBuild2DMipmaps( GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data ) { GLint rv = gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data); glReportError("gluBuild2DMipmaps"); return rv; }
void pwGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) { glGetTexImage(target, level, format, type, pixels); glReportError("glGetTexImage"); }
void pwPolygonMode(GLenum face, GLenum mode) { glPolygonMode(face, mode); glReportError("glPolygonMode"); }
void pwTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); glReportError("glTexSubImage2D"); }
void pwGenTextures(GLsizei n, GLuint *textures) { glGenTextures(n, textures); glReportError("glGenTextures"); }
///////////////////////////////////////////////////////// // Variables // void GEMglReportError :: render(GemState *state) { GLenum err=glReportError(); outlet_float(m_outlet, static_cast<t_float>(err)); }
void pwCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); glReportError("glCopyTexImage2D"); }
bool ShaderProgramBase::LoadProgram(const char* name, const char* shared, const char *vertf, const char *fragf) { ASSERT_MAIN_THREAD(); m_name = name; DPRINT(SHADER, ("Compiling %s(%s)", name, m_argstr.c_str())); string header = #if OPENGL_ES "precision highp float;\n" "precision highp sampler2D;\n" #else "#version 120\n" #endif "#define M_PI 3.1415926535897932384626433832795\n"; header += m_header + "\n"; header += shared; header += "\n"; static const char* vertheader = "attribute vec4 Position;\n" "uniform mat4 Transform;\n"; string vertful = header + vertheader + vertf; string fragful = header + fragf; GLuint vert = createShader(vertful.c_str(), GL_VERTEX_SHADER); GLuint frag = createShader(fragful.c_str(), GL_FRAGMENT_SHADER); if (!vert || !frag) return false; if (m_programHandle) { DPRINT(SHADER, ("Deleting old %s", name)); glDeleteProgram(m_programHandle); } m_programHandle = glCreateProgram(); ASSERTF(m_programHandle, "%s", m_name.c_str()); if (!m_programHandle) return false; glGetError(); glAttachShader(m_programHandle, vert); glReportError(); glAttachShader(m_programHandle, frag); glReportError(); glLinkProgram(m_programHandle); glReportError(); glDeleteShader(vert); glReportError(); glDeleteShader(frag); glReportError(); checkProgramInfoLog(m_programHandle, name); GLint linkSuccess = 0; glGetProgramiv(m_programHandle, GL_LINK_STATUS, &linkSuccess); if (linkSuccess == GL_FALSE) { DPRINT(SHADER, ("Compiling %s failed", name)); glDeleteProgram(m_programHandle); m_programHandle = 0; return false; } m_positionSlot = glGetAttribLocation(m_programHandle, "Position"); glReportError(); m_transformUniform = glGetUniformLocation(m_programHandle, "Transform"); glReportError(); return true; }
void pwTexParameteri(GLenum target, GLenum pname, GLenum param) { glTexParameteri(target, pname, param); glReportError("glTexParameteri"); }
void pwBindTexture(GLenum type, GLuint texture) { glBindTexture(type, texture); glReportError("glBindTexture"); }
void pwLineWidth(GLfloat f) { glLineWidth(f); glReportError("glLineWidth"); }
void GLRenderTexture::Generate(ZFlags zflags) { ASSERT_MAIN_THREAD(); ASSERT(m_size.x >= 1 && m_size.y >= 1); GLsizei width = m_size.x; GLsizei height = m_size.y; #if OPENGL_ES // textures must be a power of 2 on ios width = roundUpPower2(width); height = roundUpPower2(height); #endif if (s_defaultFramebuffer < 0) { glGetIntegerv(GL_FRAMEBUFFER_BINDING, &s_defaultFramebuffer); } m_texsize = float2(width, height); DPRINT(SHADER, ("Generating render texture, %dx%d %s %s", width, height, textureFormatToString(m_format), (zflags&HASZ) ? "Z16" : "No_Z")); glReportError(); glGenFramebuffers(1, &m_fbname); glReportError(); glGenTextures(1, &m_texname); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_texname); glReportError(); #if OPENGL_ES if (m_format == GL_RGBA16F_ARB) { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_HALF_FLOAT_OES, 0); } else #endif { glTexImage2D(GL_TEXTURE_2D, 0, m_format, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); } glReportError(); gpuMemoryUsed += width * height * textureFormatBytesPerPixel(m_format); glBindFramebuffer(GL_FRAMEBUFFER, m_fbname); glReportError(); // The depth buffer if (zflags&HASZ) { glGenRenderbuffers(1, &m_zrbname); glReportError(); glBindRenderbuffer(GL_RENDERBUFFER, m_zrbname); glReportError(); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height); glReportError(); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_zrbname); glReportError(); gpuMemoryUsed += width * height * 2; } else { m_zrbname = 0; } // Set "renderedTexture" as our colour attachement #0 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texname, 0); glReportError(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_texname); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); #if 0 // Set the list of draw buffers. GLenum DrawBuffers[2] = {GL_COLOR_ATTACHMENT0}; glDrawBuffers(1, DrawBuffers); // "1" is the size of DrawBuffers #endif // Always check that our framebuffer is ok glReportError(); glReportFramebufferError(); }
void pwBlendFunc(GLenum sfactor, GLenum dfactor) { glBlendFunc (sfactor, dfactor); glReportError("glBlendFunc"); }