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