bool
testFramebufferBlitLayered(int x, int y, bool srcLayered, bool dstLayered)
{
bool pass = true;
GLuint srcFBO, dstFBO;
GLuint srcTex, dstTex;
GLenum fbStatus;
/* Set up source fbo */
glGenFramebuffers(1, &srcFBO);
glBindFramebuffer(GL_FRAMEBUFFER, srcFBO);
piglit_check_gl_error(GL_NO_ERROR);
if (srcLayered) {
srcTex = create_bind_texture(GL_TEXTURE_3D, true);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
srcTex, 0);
} else {
srcTex = create_bind_texture(GL_TEXTURE_2D, true);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, srcTex, 0);
}
/* Check source framebuffer status */
fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
printf("testFramebufferBlitLayered srcFBO Status: %s\n",
piglit_get_gl_enum_name(fbStatus));
return false;
}
/* Set up dstt fbo */
glGenFramebuffers(1, &dstFBO);
glBindFramebuffer(GL_FRAMEBUFFER, dstFBO);
if (dstLayered) {
dstTex = create_bind_texture(GL_TEXTURE_3D, false);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
dstTex, 0);
} else {
dstTex = create_bind_texture(GL_TEXTURE_2D, false);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, dstTex, 0);
}
/* Check destination framebuffer status */
fbStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (fbStatus != GL_FRAMEBUFFER_COMPLETE) {
printf("testFramebufferBlitLayered dstFBO Status: %s\n",
piglit_get_gl_enum_name(fbStatus));
return false;
}
/* Check for if any errors have occured */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
printf("Error setting up framebuffers for test.\n");
return false;
}
/* Blit from source to destination framebuffers */
glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFBO);
glBlitFramebuffer(0, 0, texWidth, texHeight,
0, 0, texWidth, texHeight,
GL_COLOR_BUFFER_BIT, GL_LINEAR);
/* Display the results */
display_texture(x, y, srcTex, srcLayered ? texDepth : 1);
display_texture(x + texWidth, y, dstTex, dstLayered ? texDepth : 1);
/* Check for pass condition */
if (dstLayered) {
pass = piglit_probe_rect_rgb(x + texWidth, y,
texWidth, texHeight, srcColors[0]) && pass;
pass = piglit_probe_rect_rgb(x + texWidth, y + texHeight,
texWidth, texHeight, dstColors[1]) && pass;
} else {
pass = piglit_probe_rect_rgb(x + texWidth, y, texWidth,
texDepth * texHeight, srcColors[0]) && pass;
}
/* Clean up */
glBindFramebuffer(GL_FRAMEBUFFER, piglit_winsys_fbo);
glDeleteFramebuffers(1, &srcFBO);
glDeleteFramebuffers(1, &dstFBO);
glDeleteTextures(1, &srcTex);
glDeleteTextures(1, &dstTex);
/* Check for if any errors have occured */
if (!piglit_check_gl_error(GL_NO_ERROR)) {
printf("Error setting up framebuffers for test.\n");
return false;
}
return pass;
}
void SuzanneGL::RenderShadowMaps()
{
GLuint FramebufferName = 0;
glCreateFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glm::mat4 depthViewProjectionMatrices[NUMBER_OF_LIGHTS];
for (int i = 0; i < NUMBER_OF_LIGHTS; ++i)
{
glCreateTextures(GL_TEXTURE_2D, 1, &shadowMaps[i]);
glTextureImage2DEXT(shadowMaps[i], GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SHADOW_RESOLUTION, SHADOW_RESOLUTION, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadowMaps[i], 0);
glDrawBuffer(GL_NONE);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return;
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, SHADOW_RESOLUTION, SHADOW_RESOLUTION);
glm::vec3 lightDir = glm::normalize(glm::vec3(lighting.lights[i].position.x, lighting.lights[i].position.y, lighting.lights[i].position.z));
glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10, 10, -10, 10, -10, 20);
glm::mat4 depthViewMatrix = glm::lookAt(lightDir, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
depthViewProjectionMatrices[i] = depthProjectionMatrix * depthViewMatrix;
shadowModelMatrixIndex = glGetUniformLocation(shadowShaderProgram, "modelMatrix");
shadowViewProjectionMatrixIndex = glGetUniformLocation(shadowShaderProgram, "viewProjectionMatrix");
glProgramUniformMatrix4fv(shadowShaderProgram, shadowViewProjectionMatrixIndex, 1, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[i]));
for (ModelGL model : models)
{
glProgramUniformMatrix4fv(shadowShaderProgram, shadowModelMatrixIndex, 1, GL_FALSE, glm::value_ptr(model.modelMatrix));
glNamedBufferSubData(materialBuffer, 0, sizeof(Material), &model.material);
glBindVertexArray(model.vertexArray);
glUseProgram(shadowShaderProgram);
glDrawArrays(GL_TRIANGLES, 0, model.vertexCount);
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
shadowViewProjectionMatrixIndex = glGetUniformLocation(shaderProgram, "shadowViewProjectionMatrix");
shadowBiasMatrixIndex = glGetUniformLocation(shaderProgram, "shadowBiasMatrix");
glProgramUniformMatrix4fv(shaderProgram, shadowViewProjectionMatrixIndex, 2, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[0]));
glProgramUniformMatrix4fv(shaderProgram, shadowBiasMatrixIndex, 1, GL_FALSE, glm::value_ptr(biasMatrix));
}
bool IMaterial::FrameBufferInit()
{
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
m_fViewportWidth = viewport[2];
m_fViewportHeight = viewport[3];
glGenFramebuffers(1, &m_gFB);
glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
glGenTextures(1, &m_gMainTexFrameBuffer);
glBindTexture(GL_TEXTURE_2D, m_gMainTexFrameBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_fViewportWidth, m_fViewportHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
// glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_gMainTexFrameBuffer, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenRenderbuffers(1, &m_gRB);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRB);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, m_fViewportWidth, m_fViewportHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_gRB);
glGenRenderbuffers(1, &m_gRBDepth);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRBDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, m_fViewportWidth, m_fViewportHeight);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_gRBDepth);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// glEnable(GL_DEPTH_TEST);
// glDepthFunc(GL_LESS);
// glDepthMask(GL_TRUE);
// glDepthRangef(0.0f, 1.0f);
// glClearDepthf(1.0f);
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
__LOG("Faild to create frame buffer");
return false;
}
glGenVertexArraysOES(1, &m_gVAO);
glBindVertexArrayOES(m_gVAO);
glGenBuffers(1, &m_gVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_gVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
glEnableVertexAttribArray(SAL_POSITION);
glVertexAttribPointer(SAL_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, 0);
glEnableVertexAttribArray(SAL_TEXTURE_COORD);
glVertexAttribPointer(SAL_TEXTURE_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (char*)NULL + (sizeof(float_t) * 3));
glBindVertexArrayOES(0);
glBindFramebuffer(GL_FRAMEBUFFER, Globals::GetDefaultFramebuffer());
//glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
return true;
}
/**
* Create a new texture in the backend renderer
* @param active_texture_unit Active texture unit to bind to for creation
* @param cache_entry CacheEntry to create texture for
* @param raw_data Raw texture data
* @return a pointer to CacheEntry::BackendData with renderer-specific texture data
*/
TextureManager::CacheEntry::BackendData* TextureInterface::Create(int active_texture_unit,
const TextureManager::CacheEntry& cache_entry, u8* raw_data) {
BackendData* backend_data = new BackendData();
glActiveTexture(GL_TEXTURE0 + active_texture_unit);
switch (cache_entry.type_) {
// Normal texture from RAM
case TextureManager::kSourceType_Normal:
glGenTextures(1, &backend_data->color_texture_);
glBindTexture(GL_TEXTURE_2D, backend_data->color_texture_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, cache_entry.width_, cache_entry.height_, 0,
GL_RGBA, GL_UNSIGNED_BYTE, raw_data);
break;
// Texture is the result of an EFB copy
case TextureManager::kSourceType_EFBCopy:
{
GLuint textures[2];
glGenTextures(2, textures);
backend_data->color_texture_ = textures[0];
backend_data->depth_texture_ = textures[1];
backend_data->is_depth_copy = (cache_entry.efb_copy_data_.pixel_format_ == gp::kPixelFormat_Z24);
// Create the color component texture
glBindTexture(GL_TEXTURE_2D, backend_data->color_texture_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, cache_entry.width_, cache_entry.height_, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// Create the depth component texture
glBindTexture(GL_TEXTURE_2D, backend_data->depth_texture_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, cache_entry.width_,
cache_entry.height_, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// Create the FBO and attach color/depth textures
glGenFramebuffers(1, &backend_data->efb_framebuffer_); // Generate framebuffer
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, backend_data->efb_framebuffer_);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
backend_data->color_texture_, 0);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
backend_data->depth_texture_, 0);
// Check for completeness
GLenum res = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
_ASSERT_MSG(TGP, GL_FRAMEBUFFER_COMPLETE == res, "couldn't OpenGL EFB copy FBO!");
//////////////////////
/*glBindFramebuffer(GL_READ_FRAMEBUFFER, backend_data->efb_framebuffer_);
glReadBuffer(GL_COLOR_ATTACHMENT0);
static u8 raw_data[1024 * 1024 * 4];
static int num = 0;
num++;
glBindFramebuffer(GL_READ_FRAMEBUFFER, parent_->fbo_[RendererBase::kFramebuffer_EFB]);
glReadBuffer(GL_DEPTH_ATTACHMENT);
glReadPixels(0,0, cache_entry.width_, cache_entry.height_, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, raw_data);
// Optionally dump texture to TGA...
if (1) {
std::string filepath = common::g_config->program_dir() + std::string("/dump/efb-copies/");
common::CreateFullPath(filepath);
filepath = common::FormatStr("%s/%08x_%d.tga", filepath.c_str(), gp::g_bp_regs.efb_copy_addr << 5, num);
video_core::DumpTGA(filepath, cache_entry.width_, cache_entry.height_, raw_data);
}
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
*/
//////////////////////////////
// Rebind EFB
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, parent_->fbo_[RendererBase::kFramebuffer_EFB]);
}
break;
// Unknown texture source
default:
_ASSERT_MSG(TGP, 0, "Unknown texture source %d", (int)cache_entry.type_);
break;
}
return backend_data;
}
// The MAIN function, from here we start our application and run our Game loop
int main()
{
// Init GLFW
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", nullptr, nullptr); // Windowed
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Initialize GLEW to setup the OpenGL Function pointers
glewExperimental = GL_TRUE;
glewInit();
// Define the viewport dimensions
glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Setup and compile our shaders
Shader shader("point_shadows.vs", "point_shadows.frag");
Shader simpleDepthShader("point_shadows_depth.vs", "point_shadows_depth.frag", "point_shadows_depth.gs");
// Set texture samples
shader.Use();
glUniform1i(glGetUniformLocation(shader.Program, "diffuseTexture"), 0);
glUniform1i(glGetUniformLocation(shader.Program, "depthMap"), 1);
// Light source
glm::vec3 lightPos(0.0f, 0.0f, 0.0f);
// Load textures
woodTexture = loadTexture(FileSystem::getPath("resources/textures/wood.png").c_str());
// Configure depth map FBO
const GLuint SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
GLuint depthMapFBO;
glGenFramebuffers(1, &depthMapFBO);
// Create depth cubemap texture
GLuint depthCubemap;
glGenTextures(1, &depthCubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);
for (GLuint i = 0; i < 6; ++i)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
// Attach cubemap as depth map FBO's color buffer
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthCubemap, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
std::cout << "Framebuffer not complete!" << std::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
// Game loop
while (!glfwWindowShouldClose(window))
{
// Set frame time
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events
glfwPollEvents();
Do_Movement();
// Move light position over time
//lightPos.z = sin(glfwGetTime() * 0.5) * 3.0;
// 0. Create depth cubemap transformation matrices
GLfloat aspect = (GLfloat)SHADOW_WIDTH / (GLfloat)SHADOW_HEIGHT;
GLfloat near = 1.0f;
GLfloat far = 25.0f;
glm::mat4 shadowProj = glm::perspective(90.0f, aspect, near, far);
std::vector<glm::mat4> shadowTransforms;
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 1.0, 0.0, 0.0), glm::vec3(0.0, -1.0, 0.0)));
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3(-1.0, 0.0, 0.0), glm::vec3(0.0, -1.0, 0.0)));
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0, 1.0, 0.0), glm::vec3(0.0, 0.0, 1.0)));
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0, -1.0, 0.0), glm::vec3(0.0, 0.0, -1.0)));
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0, 0.0, 1.0), glm::vec3(0.0, -1.0, 0.0)));
shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0, 0.0, -1.0), glm::vec3(0.0, -1.0, 0.0)));
// 1. Render scene to depth cubemap
glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
glClear(GL_DEPTH_BUFFER_BIT);
simpleDepthShader.Use();
for (GLuint i = 0; i < 6; ++i)
glUniformMatrix4fv(glGetUniformLocation(simpleDepthShader.Program, ("shadowTransforms[" + std::to_string(i) + "]").c_str()), 1, GL_FALSE, glm::value_ptr(shadowTransforms[i]));
glUniform1f(glGetUniformLocation(simpleDepthShader.Program, "far_plane"), far);
glUniform3fv(glGetUniformLocation(simpleDepthShader.Program, "lightPos"), 1, &lightPos[0]);
RenderScene(simpleDepthShader);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// 2. Render scene as normal
glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.Use();
glm::mat4 projection = glm::perspective(camera.Zoom, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
glm::mat4 view = camera.GetViewMatrix();
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
// Set light uniforms
glUniform3fv(glGetUniformLocation(shader.Program, "lightPos"), 1, &lightPos[0]);
glUniform3fv(glGetUniformLocation(shader.Program, "viewPos"), 1, &camera.Position[0]);
// Enable/Disable shadows by pressing 'SPACE'
glUniform1i(glGetUniformLocation(shader.Program, "shadows"), shadows);
glUniform1f(glGetUniformLocation(shader.Program, "far_plane"), far);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, woodTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);
RenderScene(shader);
// Swap the buffers
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
void GraphicsContext3D::reshape(int width, int height)
{
if ((width == m_currentWidth && height == m_currentHeight) || (!m_private))
return;
m_currentWidth = width;
m_currentHeight = height;
makeContextCurrent();
// Create color buffer
glBindTexture(GraphicsContext3D::TEXTURE_2D, m_texture);
if (m_attrs.alpha)
glTexImage2D(GraphicsContext3D::TEXTURE_2D, /* level */ 0, GraphicsContext3D::RGBA, width, height, /* border */ 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, /* data */ 0);
else
glTexImage2D(GraphicsContext3D::TEXTURE_2D, /* level */ 0, GraphicsContext3D::RGB, width, height, /* border */ 0, GraphicsContext3D::RGB, GraphicsContext3D::UNSIGNED_BYTE, /* data */ 0);
glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
// Create depth and stencil buffers.
#if defined(QT_OPENGL_ES_2)
if (m_attrs.depth) {
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
glRenderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, width, height);
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
}
if (m_attrs.stencil) {
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_stencilBuffer);
glRenderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX8, width, height);
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
}
#else
if (m_attrs.depth || m_attrs.stencil) {
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthStencilBuffer);
if (m_attrs.depth && m_attrs.stencil)
glRenderbufferStorage(GraphicsContext3D::RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
else if (m_attrs.depth)
glRenderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT, width, height);
else if (m_attrs.stencil)
glRenderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX, width, height);
glBindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
}
#endif
// Construct canvas FBO.
glBindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
glFramebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_texture, 0);
#if defined(QT_OPENGL_ES_2)
if (m_attrs.depth)
glFramebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
if (m_attrs.stencil)
glFramebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_stencilBuffer);
#else
if (m_attrs.depth && m_attrs.stencil)
glFramebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthStencilBuffer);
else if (m_attrs.depth)
glFramebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthStencilBuffer);
else if (m_attrs.stencil)
glFramebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthStencilBuffer);
#endif
GLenum status = glCheckFramebufferStatus(GraphicsContext3D::FRAMEBUFFER);
if (status != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
LOG_ERROR("GraphicsContext3D: Canvas FBO initialization failed.");
return;
}
int clearFlags = GraphicsContext3D::COLOR_BUFFER_BIT;
if (m_attrs.depth)
clearFlags |= GraphicsContext3D::DEPTH_BUFFER_BIT;
if (m_attrs.stencil)
clearFlags |= GraphicsContext3D::STENCIL_BUFFER_BIT;
glClear(clearFlags);
glFlush();
}
void init()
{
//std::string racineProjet = "C:/Users/etu/workspace/code/Rendu temps reel/";
std::string racineProjet = "C:/Users/etu/Documents/GitHub/Gamagora-Rendu_temps_reel-TP/";
//std::string racineProjet = "B:/Utilisateur/git/code/Gamagora-Rendu_temps_reel-TP/";
// Build our program and an empty VAO
gs.programView = buildProgram((racineProjet+(std::string)"basic.vsl").c_str(), (racineProjet+(std::string)"basic.fsl").c_str());
Mesh m;
m = ObjManager::loadFromOBJ(Vector3D(0,0,0), (racineProjet+(std::string)"monkey.obj").c_str());
nbVertex = m.nbface()+6; //nbface + quad "sol"
float* data = (float*) malloc(nbVertex*4*sizeof(float));
float* dataNormal = (float*) malloc(nbVertex * 4 * sizeof(float));
std::vector<Vector3D> vertex = m.getvertex();
std::vector<int> face = m.getface();
std::vector<Vector3D> normals = m.getNormals();
std::vector<int> normalIds = m.getNormalIds();
int i=0;
for(int j=0; j<face.size(); j++){
//set vertex
data[i] = vertex[face[j]].x;
data[i+1] = vertex[face[j]].y;
data[i+2] = vertex[face[j]].z;
data[i+3] = 1;
dataNormal[i] = normals[normalIds[j]].x;
dataNormal[i+1] = normals[normalIds[j]].y;
dataNormal[i+2] = normals[normalIds[j]].z;
dataNormal[i+3] = 1;
i+=4;
}
//ajout du quad pour faire le sol
ajoutSol(Vector3D(-15,-1,-15), Vector3D(15,-1,-15), Vector3D(15,-1,15), Vector3D(-15,-1,15), Vector3D(0,1,0),
nbVertex*4, data, dataNormal);
GLuint buffer;
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, nbVertex*4*4, data, GL_STATIC_DRAW);
GLuint buffer2;
glGenBuffers(1, &buffer2);
glBindBuffer(GL_ARRAY_BUFFER, buffer2);
glBufferData(GL_ARRAY_BUFFER, nbVertex*4*4, dataNormal, GL_STATIC_READ);
glCreateVertexArrays(1, &gs.vao);
glBindVertexArray(gs.vao);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glVertexAttribPointer(12, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(12);
glBindBuffer(GL_ARRAY_BUFFER, buffer2);
glVertexAttribPointer(13, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(13);
glBindVertexArray(0);
glEnable(GL_DEPTH_TEST);
// create the depth texture
glGenTextures(1, &gs.depthTexture);
glBindTexture(GL_TEXTURE_2D, gs.depthTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, 640, 480);
// Framebuffer
glGenFramebuffers(1, &gs.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, gs.fbo);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, gs.depthTexture, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gs.depthTexture);
glBindVertexArray(0);
free(data); free(dataNormal);
}
int DemoApplication::OnInit()
{
std::cout << "DEMO APP INITIALIZED\n";
// framebuffer generation
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glGenTextures(1, &fboTexture);
glBindTexture(GL_TEXTURE_2D, fboTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 512, 512);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, fboTexture, 0);
GLenum drawBuffers[] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, drawBuffers);
glGenRenderbuffers(1, &fboDepth);
glBindRenderbuffer(GL_RENDERBUFFER, fboDepth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 512, 512);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fboDepth);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
printf("Framebuffer Error\n");
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// mesh data generation
float vertexData[] =
{
// Position UV Coords
// X, Y, Z, W, | S, T
-5, 0, -5, 1, 0, 0,
5, 0, -5, 1, 1, 0,
5, 10, -5, 1, 1, 1,
-5, 10, -5, 1, 0, 1,
};
unsigned int indexData[] =
{
0,1,2,
0,2,3,
};
// VAO-begin - will store handles to the VBO and IBO and make them available when bound
glGenVertexArrays(1, &temp.m_VAO);
glBindVertexArray(temp.m_VAO);
// VBO - describes vertex data
glGenBuffers(1, &temp.m_VBO);
glBindBuffer(GL_ARRAY_BUFFER, temp.m_VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4, vertexData, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 6, 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*)(sizeof(float) * 4));
// IBO - order to draw verticies
glGenBuffers(1, &temp.m_IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, temp.m_IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * 6, indexData, GL_STATIC_DRAW);
// VAO-end
glBindVertexArray(0); // VAO comes first! important!
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// shader program generation
// TODO: load these shaders from file
const char* vsSource = "#version 410\n \
layout(location=0) in vec4 Position;\
layout(location=1) in vec2 TexCoord;\
out vec2 vTexCoord;\
uniform mat4 ProjectionView;\
void main()\
{\
vTexCoord = TexCoord;\
gl_Position = ProjectionView * Position;\
}";
bool CreateFramebuffer(int width, int height, Framebuffer& framebuffer) {
framebuffer.bo = gbm_bo_create(gbm_, width, height, GBM_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
if (!framebuffer.bo) {
fprintf(stderr, "failed to create a gbm buffer.\n");
return false;
}
framebuffer.fd = gbm_bo_get_fd(framebuffer.bo);
if (framebuffer.fd < 0) {
fprintf(stderr, "failed to get fb for bo: %d", framebuffer.fd);
return false;
}
uint32_t handle = gbm_bo_get_handle(framebuffer.bo).u32;
uint32_t stride = gbm_bo_get_stride(framebuffer.bo);
uint32_t offset = 0;
drmModeAddFB2(drm_->GetFD(), width, height, GBM_FORMAT_XRGB8888, &handle,
&stride, &offset, &framebuffer.fb_id, 0);
if (!framebuffer.fb_id) {
fprintf(stderr, "failed to create framebuffer from buffer object.\n");
return false;
}
const EGLint khr_image_attrs[] = {EGL_DMA_BUF_PLANE0_FD_EXT,
framebuffer.fd,
EGL_WIDTH,
width,
EGL_HEIGHT,
height,
EGL_LINUX_DRM_FOURCC_EXT,
GBM_FORMAT_XRGB8888,
EGL_DMA_BUF_PLANE0_PITCH_EXT,
static_cast<const int>(stride),
EGL_DMA_BUF_PLANE0_OFFSET_EXT,
static_cast<const int>(offset),
EGL_NONE};
framebuffer.image =
egl_.CreateImageKHR(egl_.display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT,
nullptr /* no client buffer */, khr_image_attrs);
if (framebuffer.image == EGL_NO_IMAGE_KHR) {
fprintf(stderr, "failed to make image from buffer object: %s\n",
EglGetError());
return false;
}
glGenTextures(1, &framebuffer.gl_tex);
glBindTexture(GL_TEXTURE_2D, framebuffer.gl_tex);
egl_.EGLImageTargetTexture2DOES(GL_TEXTURE_2D, framebuffer.image);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffers(1, &framebuffer.gl_fb);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.gl_fb);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
framebuffer.gl_tex, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr,
"failed framebuffer check for created target buffer: %x\n",
glCheckFramebufferStatus(GL_FRAMEBUFFER));
glDeleteFramebuffers(1, &framebuffer.gl_fb);
glDeleteTextures(1, &framebuffer.gl_tex);
return false;
}
return true;
}
void RenderTarget::Activate()
{
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
if (targets.size())
{
glDrawBuffers(targets.size(), buffers);
for (size_t i = 0; i < targets.size(); i++)
{
targets[i]->SetAsAttachment(i);
}
}
if (cvx != vx || cvy != vy || cvw != vw || cvh != vh)
{
cvx = vx;
cvy = vy;
cvw = vw;
cvh = vh;
glViewport(vx, vy, vw, vh);
}
int err = glCheckFramebufferStatus(GL_FRAMEBUFFER);
switch(err)
{
case GL_FRAMEBUFFER_COMPLETE: break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: Fatal("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:Fatal("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:Fatal("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n"); break;
case GL_FRAMEBUFFER_UNSUPPORTED:Fatal("GL_FRAMEBUFFER_UNSUPPORTED\n"); break;
case GL_INVALID_FRAMEBUFFER_OPERATION:Fatal("GL_INVALID_FRAMEBUFFER_OPERATION\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB:Fatal("GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB:Fatal("GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB\n"); break;
default: Fatal("Unknown framebuffer error"); break;
}
if (depth)
{
glEnable(GL_DEPTH_TEST);
}
else
{
glDisable(GL_DEPTH_TEST);
}
static BlendMode currentBlendFunc = Overwrite;
switch(blendmode)
{
case Overwrite:
glDisable(GL_BLEND);
break;
case Alphablend:
if (currentBlendFunc != Alphablend)
{
currentBlendFunc = Alphablend;
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
glEnable(GL_BLEND);
break;
case Additive:
if (currentBlendFunc != Additive)
{
currentBlendFunc = Additive;
glBlendFunc(GL_ONE, GL_ONE);
}
glEnable(GL_BLEND);
break;
}
}
void
state_game_init(void *ptr)
{
if(!world_is_initalized())
{
error("state_game started before world_init()");
state_queue_fail();
return;
}
pos = world_get_player();
state_window_get_size(&windoww, &windowh);
//load shaders 'n stuff
gl_program_load_file(&drawprogram, "shaders/vs", "shaders/fs");
gl_program_load_file(&ppprogram, "shaders/pvs", "shaders/pfs");
modelmatrix = glGetUniformLocation(drawprogram, "MODEL");
viewprojectionmatrix = glGetUniformLocation(drawprogram, "VP");
postprocess_uniform_tex = glGetUniformLocation(ppprogram, "tex");
postprocess_uniform_depth = glGetUniformLocation(ppprogram, "depth");
postprocess_uniform_window_szie = glGetUniformLocation(ppprogram, "window_size");
//generate the post processing framebuffer
glGenFramebuffers(1, &renderbuffer.framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, renderbuffer.framebuffer);
glGenTextures(1, &renderbuffer.colorbuffer);
glGenTextures(1, &renderbuffer.depthbuffer);
glBindTexture(GL_TEXTURE_2D, renderbuffer.colorbuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, windoww, windowh, 0, GL_RGB, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, renderbuffer.depthbuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, windoww, windowh, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderbuffer.colorbuffer, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderbuffer.depthbuffer, 0);
//put the textures in thr right spots
glUseProgram(ppprogram);
GLuint tex = glGetUniformLocation(ppprogram, "tex");
GLuint depth = glGetUniformLocation(ppprogram, "depth");
glUniform1i(tex, 0);
glUniform1i(depth, 1);
//generate the post processing mesh
GLfloat mesh[] = {
-1.0f, 1.0f,
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, 1.0f,
1.0f, -1.0f
};
glGenBuffers(1, &pppointbuffer);
glBindBuffer(GL_ARRAY_BUFFER, pppointbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(mesh) * sizeof(GLfloat), mesh, GL_STATIC_DRAW);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
fail("Bad Framebuffer");
rotx = 0;
roty = 0;
posptr = entity_pos_get_ptr(pos);
vec3_t friction = {PLAYER_FRICTION,PLAYER_FRICTION,PLAYER_FRICTION};
entity_friction_set(pos, friction);
state_mouse_center();
SDL_ShowCursor(0);
ticks = SDL_GetTicks();
updatesem = SDL_CreateSemaphore(0);
updatethread = SDL_CreateThread(updatethreadfunc, "updatethread", 0);
textbox_fps = textbox_create(10, 10, 200, 100, "0fps", 0, TEXTBOX_FONT_ROBOTO_REGULAR, TEXTBOX_FONT_SIZE_MEDIUM, 0);
}
//--------------------------------------------------------------------------
GBuffer::GBuffer( unsigned int _width,
unsigned int _height)
{
// Initialize G-Buffer textures
positionTex.Allocate(GL_RGBA32F,_width,_height);
normalTex.Allocate(GL_RGBA16F,_width,_height);
diffuseTex.Allocate(GL_RGBA16F,_width,_height);
depthTex.Allocate(GL_DEPTH32F_STENCIL8,_width,_height);
positionTex.SetWrapping(GL_CLAMP_TO_EDGE,GL_CLAMP_TO_EDGE);
normalTex.SetWrapping(GL_CLAMP_TO_EDGE,GL_CLAMP_TO_EDGE);
diffuseTex.SetWrapping(GL_CLAMP_TO_EDGE,GL_CLAMP_TO_EDGE);
depthTex.SetWrapping(GL_CLAMP_TO_EDGE,GL_CLAMP_TO_EDGE);
// Initialize framebuffer
int outPosition = 0;
int outDiffuseSpecular = 1;
int outNormalRoughness = 2;
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER,framebuffer);
// Attach output textures
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0 + outPosition, positionTex.target, positionTex.id, 0);
glf::CheckFramebuffer(framebuffer);
glBindTexture(diffuseTex.target,diffuseTex.id);
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0 + outDiffuseSpecular, diffuseTex.target, diffuseTex.id, 0);
glf::CheckFramebuffer(framebuffer);
glBindTexture(normalTex.target,normalTex.id);
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0 + outNormalRoughness, normalTex.target, normalTex.id, 0);
glf::CheckFramebuffer(framebuffer);
glBindTexture(depthTex.target,depthTex.id);
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_DEPTH_STENCIL_ATTACHMENT, depthTex.target, depthTex.id, 0);
glf::CheckFramebuffer(framebuffer);
GLenum drawBuffers[3] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
glDrawBuffers(3,drawBuffers);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Program regular mesh
ProgramOptions regularOptions = ProgramOptions::CreateVSOptions();
regularOptions.AddDefine<int>("GBUFFER", 1);
regularOptions.AddDefine<int>("OUT_POSITION", outPosition);
regularOptions.AddDefine<int>("OUT_DIFFUSE_SPECULAR", outDiffuseSpecular);
regularOptions.AddDefine<int>("OUT_NORMAL_ROUGHNESS", outNormalRoughness);
regularRenderer.program.Compile(regularOptions.Append(LoadFile(directory::ShaderDirectory + "meshregular.vs")),
regularOptions.Append(LoadFile(directory::ShaderDirectory + "meshregular.fs")));
regularRenderer.transformVar = regularRenderer.program["Transform"].location;
regularRenderer.modelVar = regularRenderer.program["Model"].location;
regularRenderer.diffuseTexUnit = regularRenderer.program["DiffuseTex"].unit;
regularRenderer.normalTexUnit = regularRenderer.program["NormalTex"].unit;
regularRenderer.roughnessVar = regularRenderer.program["Roughness"].location;
regularRenderer.specularityVar = regularRenderer.program["Specularity"].location;
glProgramUniform1i(regularRenderer.program.id, regularRenderer.program["DiffuseTex"].location, regularRenderer.diffuseTexUnit);
glProgramUniform1i(regularRenderer.program.id, regularRenderer.program["NormalTex"].location, regularRenderer.normalTexUnit);
// Program terrain mesh
ProgramOptions terrainOptions = ProgramOptions::CreateVSOptions();
terrainOptions.AddDefine<int>("GBUFFER", 1);
terrainOptions.AddDefine<int>("OUT_POSITION", outPosition);
terrainOptions.AddDefine<int>("OUT_DIFFUSE_SPECULAR", outDiffuseSpecular);
terrainOptions.AddDefine<int>("OUT_NORMAL_ROUGHNESS", outNormalRoughness);
terrainRenderer.program.Compile(terrainOptions.Append(LoadFile(directory::ShaderDirectory + "meshterrain.vs")),
terrainOptions.Append(LoadFile(directory::ShaderDirectory + "meshterrain.cs")),
terrainOptions.Append(LoadFile(directory::ShaderDirectory + "meshterrain.es")),
terrainOptions.Append(LoadFile(directory::ShaderDirectory + "meshterrain.fs")));
terrainRenderer.transformVar = terrainRenderer.program["Transform"].location;
terrainRenderer.diffuseTexUnit = terrainRenderer.program["DiffuseTex"].unit;
terrainRenderer.normalTexUnit = terrainRenderer.program["NormalTex"].unit;
terrainRenderer.heightTexUnit = terrainRenderer.program["HeightTex"].unit;
terrainRenderer.roughnessVar = terrainRenderer.program["Roughness"].location;
terrainRenderer.specularityVar = terrainRenderer.program["Specularity"].location;
terrainRenderer.tileSizeVar = terrainRenderer.program["TileSize"].location;
terrainRenderer.tileCountVar = terrainRenderer.program["TileCount"].location;
terrainRenderer.tileOffsetVar = terrainRenderer.program["TileOffset"].location;
terrainRenderer.projFactorVar = terrainRenderer.program["ProjFactor"].location;
terrainRenderer.tessFactorVar = terrainRenderer.program["TessFactor"].location;
terrainRenderer.heightFactorVar = terrainRenderer.program["HeightFactor"].location;
terrainRenderer.tileFactorVar = terrainRenderer.program["TileFactor"].location;
glProgramUniform1i(terrainRenderer.program.id, terrainRenderer.program["DiffuseTex"].location, terrainRenderer.diffuseTexUnit);
glProgramUniform1i(terrainRenderer.program.id, terrainRenderer.program["NormalTex"].location, terrainRenderer.normalTexUnit);
glProgramUniform1i(terrainRenderer.program.id, terrainRenderer.program["HeightTex"].location, terrainRenderer.heightTexUnit);
glf::CheckError("GBuffer::GBuffer");
}
void Grid::initData()
{
D = 2, Q = 9;
demo = 0;
//Input horizontal velocity
vx = Settings::root["vx"].asFloat();
//Input vertical velocity
vy = Settings::root["vy"].asFloat();
//Input density ρ = rho
rho = Settings::root["rho"].asFloat();
//Relaxation time τ = tau
tau = Settings::root["tau"].asFloat();
//Wrapping
hWrap = Settings::root["wrap"]["horizontal"].asBool();
vWrap = Settings::root["wrap"]["vertical"].asBool();
lattice.resize(Q*num);
solid.resize(2);
for(int i=0; i<solid.size(); ++i)
solid[i].resize(num);
float w0 = 4.f/9.f;
float w1 = 1.f/9.f;
float w2 = 1.f/36.f;
float vSq = 1.5f*(vx*vx+vy*vy);
//Fill lattice with equilibrium velocities
for(int i=0; i<num; ++i)
{
int j=i*Q;
lattice[j] = w0*rho*(1.f -vSq);
lattice[j+1] = w1*rho*(1.f+3.f*vx +4.5f*vx*vx -vSq);
lattice[j+2] = w1*rho*(1.f+3.f*vy +4.5f*vy*vy -vSq);
lattice[j+3] = w1*rho*(1.f-3.f*vx +4.5f*vx*vx -vSq);
lattice[j+4] = w1*rho*(1.f-3.f*vy +4.5f*vy*vy -vSq);
lattice[j+5] = w2*rho*(1.f+3.f*( vx+vy) +4.5f*( vx+vy)*( vx+vy) -vSq);
lattice[j+6] = w2*rho*(1.f+3.f*(-vx+vy) +4.5f*(-vx+vy)*(-vx+vy) -vSq);
lattice[j+7] = w2*rho*(1.f+3.f*(-vx-vy) +4.5f*(-vx-vy)*(-vx-vy) -vSq);
lattice[j+8] = w2*rho*(1.f+3.f*( vx-vy) +4.5f*( vx-vy)*( vx-vy) -vSq);
solid[0][i] = false;
solid[1][i] = true;
}
lSize = Q*num*sizeof(float);
size_t size = num*sizeof(float);
//create renderbuffer
glGenRenderbuffers(1, &rendBuff);
glBindRenderbuffer(GL_RENDERBUFFER, rendBuff);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32F, width, height);
glGenFramebuffers(1, &frameBuff);
glBindFramebuffer(GL_FRAMEBUFFER, frameBuff);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rendBuff);
//Check renderbuffer completeness
GLenum hey = glCheckFramebufferStatus(GL_FRAMEBUFFER);
std::cout<<"Framebuffer:";
switch(hey)
{
case GL_FRAMEBUFFER_COMPLETE: std::cout<<"complete"; break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: std::cout<<"incomplete attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: std::cout<<"incomplete missing attachment"; break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: std::cout<<"incomplete draw buffer"; break;
default: std::cout<<"unknown"; break;
}
std::cout<<std::endl;
glFinish();
//Create OpenCL memory pointer for renderbuffer
clVBOs.push_back(cl::BufferRenderGL(context, CL_MEM_READ_WRITE, rendBuff));
clLattice.push_back(cl::Buffer(context, CL_MEM_WRITE_ONLY, lSize));
clLattice.push_back(cl::Buffer(context, CL_MEM_WRITE_ONLY, lSize));
clVelMag = cl::Buffer(context, CL_MEM_WRITE_ONLY, size);
for(int i=0; i<solid.size(); ++i)
clSolid.push_back(cl::Buffer(context, CL_MEM_WRITE_ONLY, num*sizeof(char)));
try
{
//Lattice can be copied to both memory locations for debugging
//queue.enqueueWriteBuffer(clLattice[0], CL_TRUE, 0, lSize, &lattice[0], NULL, &event);
queue.enqueueWriteBuffer(clLattice[1], CL_TRUE, 0, lSize, &lattice[0], NULL, &event);
for(int i=0; i<solid.size(); i++)
queue.enqueueWriteBuffer(clSolid[i], CL_TRUE, 0, num*sizeof(char), &(solid[i])[0], NULL, &event);
queue.finish();
}
catch(cl::Error e)
{
cluErr("Grid: initData", e);
}
//init kernels
try
{
clStream = cl::Kernel(program, "stream");
clHWrap = cl::Kernel(program, "hWrap");
clVWrap = cl::Kernel(program, "vWrap");
clSolidBB = cl::Kernel(program, "solidBB");
clInflow = cl::Kernel(program, "inflow");
clCollide = cl::Kernel(program, "collide");
clRender = cl::Kernel(program, "render");
}
catch(cl::Error e)
{
cluErr("Grid: initData", e);
}
try
{
//Set constant arguments for each kernel
clStream.setArg(2, width);
clStream.setArg(3, height);
clHWrap.setArg(1, width);
clHWrap.setArg(2, height);
clVWrap.setArg(1, width);
clVWrap.setArg(2, height);
clSolidBB.setArg(2, width);
clInflow.setArg(1, vx);
clInflow.setArg(2, vy);
clInflow.setArg(3, rho);
clInflow.setArg(4, width);
clCollide.setArg(1, clVelMag);
clCollide.setArg(2, width);
clCollide.setArg(3, tau);
clRender.setArg(0, clVelMag);
clRender.setArg(2, width);
clRender.setArg(3, height);
clRender.setArg(4, vx);
clRender.setArg(5, vy);
clRender.setArg(6, clVBOs[0]);
queue.finish();
}
catch(cl::Error e)
{
cluErr("Grid: initData", e);
}
//Set framebuffer addressing for blitting at the end of rendering
glBindFramebuffer(GL_READ_FRAMEBUFFER, frameBuff);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
void RenderTarget::Initialize(mathfu::vec2i dimensions, GLenum format,
bool create_depth_buffer) {
assert(!initialized());
dimensions_ = dimensions;
// Set up the framebuffer itself:
framebuffer_id_ = 0;
depth_buffer_id_ = 0;
// Our framebuffer object:
GL_CALL(glGenFramebuffers(1, &framebuffer_id_));
// The texture we're going to render to
GL_CALL(glGenTextures(1, &rendered_texture_id_));
// Bind the framebuffer:
GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_));
// Set up the texture:
GL_CALL(glBindTexture(GL_TEXTURE_2D, rendered_texture_id_));
// Give an empty image to OpenGL. (It will allocate memory, but not bother
// to populate it. Which is fine, since we're going to render into it.)
GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, dimensions.x(),
dimensions.y(), 0, GL_RGBA, format, nullptr));
// Define texture properties:
GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
// Attach our texture as the color attachment.
GL_CALL(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, rendered_texture_id_, 0));
if (create_depth_buffer) {
// A renderbuffer, that we'll use for depth:
GL_CALL(glGenRenderbuffers(1, &depth_buffer_id_));
// Bind renderbuffer and set it as the depth buffer:
GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer_id_));
GL_CALL(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
dimensions_.x(), dimensions_.y()));
// Attach renderbuffer as our depth attachment.
GL_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depth_buffer_id_));
}
// Make sure everything worked:
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
assert(false);
}
assert(framebuffer_id_ != 0);
assert(depth_buffer_id_ != 0);
// Be good citizens and clean up:
// Bind the framebuffer:
GL_CALL(glBindTexture(GL_TEXTURE_2D, 0));
GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
GL_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0));
initialized_ = true;
}
Renderer::Renderer(Window &parent) : OGLRenderer(parent) {
camera = new Camera(-30.0f, 180.0f, Vector3(0.0f, -1500.0f, 0.0f));
quad = Mesh::GenerateQuad();
quad_corner = Mesh::GenerateQuad();
heightMap = new HeightMap(TEXTUREDIR"terrain.raw");
heightMap->SetTexture(SOIL_load_OGL_texture(TEXTUREDIR"BarrenReds.JPG", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS));
sceneShader = new Shader(SHADERDIR"Test_03_TexturedVertex.glsl", SHADERDIR"Test_03_TexturedFragment.glsl");
bool sceneFlag = sceneShader->LinkProgram();
combineShader = new Shader(SHADERDIR"Test_03_TexturedVertex.glsl", SHADERDIR"Test_10_ProcessFragment.glsl");
bool combFlag = combineShader->LinkProgram();
if (!combineShader->LinkProgram() || !sceneShader->LinkProgram() || !heightMap->GetTexture()) {
return;
}
SetTextureRepeating(heightMap->GetTexture(), true);
// scene depth texture
glGenTextures(1, &bufferDepthTex);
glBindTexture(GL_TEXTURE_2D, bufferDepthTex);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, width, height, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, NULL);
// colour texture
for (int i = 0; i < 2; ++i) {
glGenTextures(1, &bufferColourTex[i]);
glBindTexture(GL_TEXTURE_2D, bufferColourTex[i]);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
glGenTextures(1, &debugColorTex);
glBindTexture(GL_TEXTURE_2D, debugColorTex);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 800, 600, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
// set up buffer for scene rendering and post processing
glGenFramebuffers(1, &bufferFBO);
glGenFramebuffers(1, &processFBO);
glGenFramebuffers(1, &debugbufferFBO);
glBindFramebuffer(GL_FRAMEBUFFER, bufferFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, bufferDepthTex, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, bufferDepthTex, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, bufferColourTex[0], 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE || !bufferDepthTex || !bufferColourTex[0]) {
return;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glEnable(GL_DEPTH_TEST);
init = true;
}
Map::Map(const char *map, Style* style){
this->style = style;
Filereader* reader = new Filereader(map);
Chunk *animation_data;
Chunk *dmap_data;
Chunk *chk;
while((chk = reader->getNextChunk())){
if(strncmp(chk->header->type,"ANIM",4) == 0) {
animation_data = chk;
}
if(strncmp(chk->header->type,"DMAP",4) == 0) {
dmap_data = chk;
}
}
// Read animation data
char* starting = animation_data->data;
char* offset = animation_data->data;
while((int)offset - (int)starting < animation_data->header->size )
{
TileAnimation anim;
anim.base = *reinterpret_cast<short*>(offset);
offset += sizeof(short);
anim.frame_rate = *reinterpret_cast<char*>(offset);
offset += sizeof(char);
anim.repeat = *reinterpret_cast<unsigned char*>(offset);
offset += sizeof(unsigned char);
anim.anim_length = *reinterpret_cast<char*>(offset);
offset += sizeof(char);
// unused char in file structure
offset += sizeof(char);
anim.tiles = reinterpret_cast<short*>(offset);
offset += anim.anim_length * sizeof(short);
std::vector<int> animationTiles;
for(int i=0; i<anim.anim_length;i++)
{
animationTiles.push_back(anim.tiles[i]);
}
animatedGeom[anim.base].curTile = 0;
animatedGeom[anim.base].tick = 0;
animatedGeom[anim.base].anim = anim;
animatedGeom[anim.base].animationTiles = animationTiles;
animatedGeom[anim.base+1000].curTile = 0;
animatedGeom[anim.base+1000].tick = 0;
animatedGeom[anim.base+1000].anim = anim;
animatedGeom[anim.base+1000].animationTiles = animationTiles;
tileAnimations.push_back(anim);
std::cout << anim.base << " " << (int)anim.frame_rate << " " << (int)anim.repeat << " " << (int)anim.anim_length << " " << anim.tiles[1] << " " << animationTiles.size() << std::endl;
}
// Read dmap data
CompressedMap c_map;
offset = dmap_data->data;
c_map.base = reinterpret_cast<int*>(offset);
offset += 256 * 256 * sizeof(int);
c_map.column_words = *reinterpret_cast<int*>(offset);
offset += sizeof(int);
c_map.columns = reinterpret_cast<int*>(offset);
offset += c_map.column_words * sizeof(int);
c_map.num_blocks = *reinterpret_cast<int*>(offset);
offset += sizeof(int);
c_map.blocks = reinterpret_cast<BlockInfo*>(offset);
offset += c_map.num_blocks * sizeof(BlockInfo);
for(int x=0;x<255;x++) for(int y=0;y<255;y++)
{
int base = c_map.base[y*256+x];
ColInfo* column = reinterpret_cast<ColInfo*>(c_map.columns + base);
int i = 0;
for(i=0;i<(column->height-column->offset);i++){
this->addBlock(c_map.blocks[column->blockd[i]], Vector3(x, -y, i+column->offset));
}
}
delete reader;
GLenum FBOstatus;
glGenTextures(1, &depthTextureId);
glBindTexture(GL_TEXTURE_2D, depthTextureId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadowMapWidth, shadowMapHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffers(1, &fboId);
glBindFramebuffer(GL_FRAMEBUFFER, fboId);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTextureId, 0);
FBOstatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(FBOstatus != GL_FRAMEBUFFER_COMPLETE)
{
std::cout << "FBO error: " << FBOstatus << std::endl;
}
glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
}
void processFn(struct fnargs* args) {
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
free((void*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)args->a1);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
free(*(void**)args->a2);
free((void*)args->a2);
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)args->a7);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)args->a8);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
}
renderToTexture::renderToTexture(int width, int height, bool depthTest, GLenum format) : width(width), height(height), depthTest(depthTest), format(format) {
this->gen();
setupThrow(LOG, glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE, "Setup done");
}
GC3Denum GraphicsContext3D::checkFramebufferStatus(GC3Denum target)
{
makeContextCurrent();
return glCheckFramebufferStatus(target);
}
bool OlaGLRenderTarget::initialize( int w ,int h )
{
release();
mWidth = w;
mHeight = h;
//color buffer
unsigned int color_rb = 0;
glGenTextures(1, &color_rb);
lgGLError("color buffer gen failed in rt \n");
glBindTexture(GL_TEXTURE_2D, color_rb);
lgGLError("color buffer bind failed in rt \n");
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mWidth, mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE , 0); //rgba GL_UNSIGNED_SHORT_5_6_5 GL_UNSIGNED_BYTE
lgGLError("color buffer create failed in rt \n");
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//depth buffer
unsigned int depth_rb = 0;
glGenTextures(1, &depth_rb);
lgGLError("depth buffer gen failed in rt \n");
glBindTexture(GL_TEXTURE_2D, depth_rb);
lgGLError("depth buffer bind failed in rt \n");
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, mWidth, mHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT , 0); //rgba GL_UNSIGNED_SHORT_5_6_5 GL_UNSIGNED_BYTE
lgGLError("depth buffer create failed in rt \n");
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
//stencil buffer
//unsigned int stencel_buffer = 0;
//glGenRenderbuffers(1,&stencel_buffer);
//glBindRenderbuffer(GL_RENDERBUFFER,stencel_buffer);
//glRenderbufferStorage(GL_RENDERBUFFER,GL_STENCIL_INDEX8,mWidth,mHeight);
//lgGLError("stencil buffer create failed in rt \n");
//glBindRenderbuffer(GL_RENDERBUFFER,0);
unsigned int fbo = 0;
glGenFramebuffers(1,&fbo);
glBindFramebuffer(GL_FRAMEBUFFER,fbo);
lgGLError("frame buffer gen failed in rt \n");
mHandles[OlaRTParam::FRAME_BUFFER] = fbo;
mHandles[OlaRTParam::COLOR_BUFFER] = color_rb;
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D, color_rb,0);
lgGLError("color buffer attach failed in rt \n");
mHandles[OlaRTParam::DEPTH_BUFFER] = depth_rb;
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, depth_rb, 0);
lgGLError("depth buffer attach failed in rt \n");
//mHandles[OlaRTParam::STENCIL_BUFFER] = stencel_buffer;
//glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_STENCIL_ATTACHMENT,GL_RENDERBUFFER,stencel_buffer);
//lgGLError("stencil buffer attach failed in rt \n");
GLenum hr = glCheckFramebufferStatus(GL_FRAMEBUFFER);
switch (hr)
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
lg("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
lg("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
lg("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
lg("GL_FRAMEBUFFER_UNSUPPORTED");
break;
case GL_FRAMEBUFFER_COMPLETE:
break;
}
glBindFramebuffer(GL_FRAMEBUFFER,0);
return true;
}
DepthBuffer::DepthBuffer(unsigned int width, unsigned height) : width(width),
height(height) {
// Create FBO
// --------------------------------------------------------------------------
glGenFramebuffers(1, &(this->p_fbo));
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, this->p_fbo);
// Create colour output texture buffer
// --------------------------------------------------------------------------
glGenTextures(1, &(this->p_colour_texture));
glBindTexture(GL_TEXTURE_2D, this->p_colour_texture);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGB32F,
this->width, this->height,
0,
GL_RGB,
GL_UNSIGNED_SHORT_5_6_5,
NULL
);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// Attach texture the framebuffer object
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, // target
GL_COLOR_ATTACHMENT0, // attachment
GL_TEXTURE_2D, // textarget
this->p_colour_texture, // texture
0 // level (mipmap level)
);
// Create depth texture buffer
// --------------------------------------------------------------------------
glGenTextures(1, &(this->p_depth_texture));
glBindTexture(GL_TEXTURE_2D, this->p_depth_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_DEPTH_COMPONENT32F,
this->width, this->height,
0,
GL_DEPTH_COMPONENT,
GL_FLOAT,
NULL
);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_TEXTURE_2D,
this->p_depth_texture,
0
);
//glDrawBuffer(GL_NONE);
GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, draw_buffers);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
throw std::runtime_error(std::string("FB error, status: 0x%x\n", status));
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
/*---------------------------------------------------------------------------
Setup function that a intialises assets, matrices and other OpenGL
related structure for rendering. NOTE: This must be called within a
valid OpenGL context.
---------------------------------------------------------------------------*/
void Filter::Setup(Buffers &Buffer)
{
Destroy();
if (!GLEW_ARB_framebuffer_object)
{throw dexception("Current OpenGL context does not support frame buffer objects.");}
vector2u Res;
switch (Select)
{
case Filter::SelectVideo : Res = Buffer.GetVideoResolution(); break;
case Filter::SelectDepth : Res = Buffer.GetDepthResolution(); break;
default : throw dexception("Invalid Select enumeration.");;
}
if (Res.X < 1 || Res.Y < 1) {return;}
//Create a new frame buffer object
glGenFramebuffers(1, &FBOID);
glBindFramebuffer(GL_FRAMEBUFFER, FBOID);
//Create a new depth buffer object, then associate a
// storage space for it, and attach it to the FBO
glGenRenderbuffers(1, &DBOID);
glBindRenderbuffer(GL_RENDERBUFFER, DBOID);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, Res.X, Res.Y);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, DBOID);
//Create a colour buffer in form of a texture and attach it to the FBO
glGenTextures(1, &CBOID);
glBindTexture(GL_TEXTURE_2D, CBOID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, Res.X, Res.Y, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, CBOID, 0);
//FBO texture scaling
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
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_GENERATE_MIPMAP, GL_TRUE);
//Setup view port size
ViewPort.Set4(0, 0, Res.X, Res.Y);
//Compute frustum aspect ratio from viewport size
Ratio.Set((float)ViewPort.C2, (float)ViewPort.C3);
Ratio /= (float)Math::Min(ViewPort.C2, ViewPort.C3);
//Default projection matrix
MP = MP.Identity();
MP = MP.Ortho(-Ratio.X, Ratio.X, -Ratio.Y, Ratio.Y, Near, Far);
//Default model view matrix
MV = MV.Identity();
MV = MV.Scale(Ratio.X, Ratio.Y, 1.0f);
//Default texture matrix
MT = MT.Identity();
//MT = MT.Scale(1.0f, -1.0f, 1.0f);
//MT = MT.Translate(0.0f, -1.0f, 0.0f);
MC = MC.Identity();
//Error checking
GLenum Error = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (Error != GL_FRAMEBUFFER_COMPLETE) {throw dexception("Failed to setup frame buffer object: %s.", Debug::StatusFBO(Error));}
Error = glGetError();
if (Error != GL_NO_ERROR) {throw dexception("OpenGL generated an error: %s", Debug::ErrorGL(Error));}
}
void CGLFramebuffer::Create()
{
if (m_fbo != 0) return;
m_width = m_params.width;
m_height = m_params.height;
m_depth = m_params.depth;
m_samples = m_params.samples;
glGenFramebuffers(1, &m_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
// create color texture
if (m_params.colorTexture)
{
GLint previous;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &previous);
glGenTextures(1, &m_colorTexture);
glBindTexture(GL_TEXTURE_2D, m_colorTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_params.width, m_params.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, previous);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorTexture, 0);
}
// create color renderbuffer
else
{
glGenRenderbuffers(1, &m_colorRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_colorRenderbuffer);
if (m_params.samples > 1)
glRenderbufferStorageMultisample(GL_RENDERBUFFER, m_params.samples, GL_RGBA8, m_params.width, m_params.height);
else
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, m_params.width, m_params.height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorRenderbuffer);
}
GLuint depthFormat = 0;
switch (m_params.depth)
{
case 16: depthFormat = GL_DEPTH_COMPONENT16; break;
case 24: depthFormat = GL_DEPTH_COMPONENT24; break;
case 32: depthFormat = GL_DEPTH_COMPONENT32; break;
default: depthFormat = GL_DEPTH_COMPONENT16; break;
}
// create depth texture
if (m_params.depthTexture)
{
GLint previous;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &previous);
glGenTextures(1, &m_depthTexture);
glBindTexture(GL_TEXTURE_2D, m_depthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, depthFormat, m_params.width, m_params.height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color);
glBindTexture(GL_TEXTURE_2D, previous);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthTexture, 0);
}
// create depth renderbuffer
else
{
glGenRenderbuffers(1, &m_depthRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_depthRenderbuffer);
if (m_params.samples > 1)
glRenderbufferStorageMultisample(GL_RENDERBUFFER, m_params.samples, depthFormat, m_params.width, m_params.height);
else
glRenderbufferStorage(GL_RENDERBUFFER, depthFormat, m_params.width, m_params.height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthRenderbuffer);
}
GLuint result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (result != GL_FRAMEBUFFER_COMPLETE)
{
GetLogger()->Error("Framebuffer incomplete\n");
assert(false);
}
glBindFramebuffer(GL_FRAMEBUFFER, m_currentFBO);
}
void opengl_window::render()
{
if (iRendering || processing_event())
return;
uint64_t now = app::instance().program_elapsed_ms();
if (iFrameRate != boost::none && now - iLastFrameTime < 1000 / *iFrameRate)
return;
if (!iEventHandler.native_window_ready_to_render())
return;
rendering_check.trigger();
if (iInvalidatedRects.empty())
return;
++iFrameCounter;
iRendering = true;
iLastFrameTime = now;
rendering.trigger();
rect invalidatedRect = *iInvalidatedRects.begin();
for (const auto& ir : iInvalidatedRects)
{
invalidatedRect = invalidatedRect.combine(ir);
}
iInvalidatedRects.clear();
invalidatedRect.cx = std::min(invalidatedRect.cx, surface_size().cx - invalidatedRect.x);
invalidatedRect.cy = std::min(invalidatedRect.cy, surface_size().cy - invalidatedRect.y);
static bool initialized = false;
if (!initialized)
{
rendering_engine().initialize();
initialized = true;
}
activate_context();
glCheck(glViewport(0, 0, static_cast<GLsizei>(extents().cx), static_cast<GLsizei>(extents().cy)));
glCheck(glMatrixMode(GL_PROJECTION));
glCheck(glLoadIdentity());
glCheck(glScalef(1.0, 1.0, 1.0));
glCheck(glMatrixMode(GL_MODELVIEW));
glCheck(glLoadIdentity());
const auto& logicalCoordinates = logical_coordinates();
glCheck(glOrtho(logicalCoordinates[0], logicalCoordinates[2], logicalCoordinates[1], logicalCoordinates[3], -1.0, 1.0));
glCheck(glEnableClientState(GL_VERTEX_ARRAY));
glCheck(glEnableClientState(GL_COLOR_ARRAY));
glCheck(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
glCheck(glEnable(GL_TEXTURE_2D));
glCheck(glEnable(GL_MULTISAMPLE));
glCheck(glEnable(GL_BLEND));
if (iFrameBufferSize.cx < static_cast<double>(extents().cx) || iFrameBufferSize.cy < static_cast<double>(extents().cy))
{
if (iFrameBufferSize != size{})
{
glCheck(glDeleteRenderbuffers(1, &iDepthStencilBuffer));
glCheck(glDeleteTextures(1, &iFrameBufferTexture));
glCheck(glDeleteFramebuffers(1, &iFrameBuffer));
}
iFrameBufferSize = size(
iFrameBufferSize.cx < extents().cx ? extents().cx * 1.5f : iFrameBufferSize.cx,
iFrameBufferSize.cy < extents().cy ? extents().cy * 1.5f : iFrameBufferSize.cy);
glCheck(glGenFramebuffers(1, &iFrameBuffer));
glCheck(glBindFramebuffer(GL_FRAMEBUFFER, iFrameBuffer));
glCheck(glGenTextures(1, &iFrameBufferTexture));
glCheck(glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, iFrameBufferTexture));
glCheck(glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, static_cast<GLsizei>(iFrameBufferSize.cx), static_cast<GLsizei>(iFrameBufferSize.cy), true));
glCheck(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, iFrameBufferTexture, 0));
glCheck(glGenRenderbuffers(1, &iDepthStencilBuffer));
glCheck(glBindRenderbuffer(GL_RENDERBUFFER, iDepthStencilBuffer));
glCheck(glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, static_cast<GLsizei>(iFrameBufferSize.cx), static_cast<GLsizei>(iFrameBufferSize.cy)));
glCheck(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, iDepthStencilBuffer));
glCheck(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, iDepthStencilBuffer));
}
else
{
glCheck(glBindFramebuffer(GL_FRAMEBUFFER, iFrameBuffer));
glCheck(glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, iFrameBufferTexture));
glCheck(glBindRenderbuffer(GL_RENDERBUFFER, iDepthStencilBuffer));
}
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_NO_ERROR && status != GL_FRAMEBUFFER_COMPLETE)
throw failed_to_create_framebuffer(status);
glCheck(glBindFramebuffer(GL_FRAMEBUFFER, iFrameBuffer));
GLenum drawBuffers[] = { GL_COLOR_ATTACHMENT0 };
glCheck(glDrawBuffers(sizeof(drawBuffers) / sizeof(drawBuffers[0]), drawBuffers));
glCheck(iEventHandler.native_window_render(invalidatedRect));
glCheck(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0));
glCheck(glBindFramebuffer(GL_READ_FRAMEBUFFER, iFrameBuffer));
glCheck(glBlitFramebuffer(0, 0, static_cast<GLint>(extents().cx), static_cast<GLint>(extents().cy), 0, 0, static_cast<GLint>(extents().cx), static_cast<GLint>(extents().cy), GL_COLOR_BUFFER_BIT, GL_NEAREST));
display();
deactivate_context();
iRendering = false;
rendering_finished.trigger();
}
EGBufferStatus::Value CheckFramebufferStatus(const EGBuffer::Value Target)
{
const EGBufferStatus::Value Status = static_cast<EGBufferStatus::Value>(glCheckFramebufferStatus(Target));
return Status;
}
void Framebuffer::prepare(RenderState& rs, GLuint unit) {
m_colorTexture.prepare(rs, unit);
// Generate framebuffer handle.
CHECK_GL(glGenFramebuffers(1, &m_framebufferHandle));
if (m_options.hasDepth) {
// Generate depth buffer handle.
CHECK_GL(glGenRenderbuffers(1, &m_depthbufferHandle));
}
if (m_options.hasStencil) {
// Generate stencil buffer handle.
CHECK_GL(glGenRenderbuffers(1, &m_stencilbufferHandle));
}
// Bind color texture.
m_colorTexture.bind(rs, unit);
if (m_options.hasDepth) {
// Create depth buffer storage.
CHECK_GL(glBindRenderbuffer(GL_RENDERBUFFER, m_depthbufferHandle));
CHECK_GL(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, m_width, m_height));
}
if (m_options.hasStencil) {
// Create stencil buffer storage.
CHECK_GL(glBindRenderbuffer(GL_RENDERBUFFER, m_stencilbufferHandle));
CHECK_GL(glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, m_width, m_height));
}
// Bind the framebuffer.
CHECK_GL(glBindFramebuffer(GL_FRAMEBUFFER, m_framebufferHandle));
// Attach the color buffer.
CHECK_GL(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorTexture.glHandle(), 0));
if (m_options.hasDepth) {
// Attach the depth buffer.
CHECK_GL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthbufferHandle));
}
if (m_options.hasStencil) {
// Attach the stencil buffer.
CHECK_GL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencilbufferHandle));
}
// Unbind renderbuffer object.
CHECK_GL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
// Check framebuffer status.
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
CHECK_GL();
// Bind the default framebuffer object.
CHECK_GL(glBindFramebuffer(GL_FRAMEBUFFER, 0));
// Check status and dispose on failure.
if (status != GL_FRAMEBUFFER_COMPLETE) {
dispose(rs);
switch (status) {
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
Log::e("Error creating framebuffer: GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
Log::e("Error creating framebuffer: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
Log::e("Error creating framebuffer: GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
Log::e("Error creating framebuffer: GL_FRAMEBUFFER_UNSUPPORTED");
break;
default:
Log::e("Error creating framebuffer: Unrecognized error.");
break;
}
}
}
bool CMaterialGlow::Init(SMaterialData* Data)
{
if (Data == nullptr)
return false;
// static float_t quad[30] =
// {
// -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
// 1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
// 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
// -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
// 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
// -1.0f, 1.0f, 0.0f, 0.0f, 1.0f
// };
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
m_gTextureWidth = viewport[2];
m_gTextureHeight = viewport[3];
//
// glGenTextures(1, &m_gTexture);
//
// glBindTexture(GL_TEXTURE_2D, m_gTexture);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//
// if (!loadBmpImage(data->TextureFileName.c_str()))
// return false;
glGenFramebuffers(1, &m_gFB);
glGenRenderbuffers(1, &m_gRB);
glGenTextures(2, m_gTexture);
glBindTexture(GL_TEXTURE_2D, m_gTexture[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_gTextureWidth, m_gTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, m_gTexture[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_gTextureWidth, m_gTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindRenderbuffer(GL_RENDERBUFFER, m_gRB);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8_OES, m_gTextureWidth, m_gTextureHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_gFB);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_gRB);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
__LOG("Faild to create frame buffer");
return false;
}
glBindFramebuffer(GL_FRAMEBUFFER, Globals::GetDefaultFramebuffer());
glGenVertexArraysOES(1, &m_gVAO);
glBindVertexArrayOES(m_gVAO);
glGenBuffers(1, &m_gVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_gVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
glEnableVertexAttribArray(SAL_POSITION);
glVertexAttribPointer(SAL_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, 0);
glEnableVertexAttribArray(SAL_TEXTURE_COORD);
glVertexAttribPointer(SAL_TEXTURE_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (char*)NULL + (sizeof(float_t) * 3));
glBindVertexArrayOES(0);
return true;
}
bool CCRenderTexture::initWithWidthAndHeight(int w, int h, CCTexture2DPixelFormat eFormat, GLuint uDepthStencilFormat)
{
CCAssert(eFormat != kCCTexture2DPixelFormat_A8, "only RGB and RGBA formats are valid for a render texture");
bool bRet = false;
void *data = NULL;
do
{
w = (int)(w * CC_CONTENT_SCALE_FACTOR());
h = (int)(h * CC_CONTENT_SCALE_FACTOR());
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_nOldFBO);
// textures must be power of two squared
unsigned int powW = 0;
unsigned int powH = 0;
if (CCConfiguration::sharedConfiguration()->supportsNPOT())
{
powW = w;
powH = h;
}
else
{
powW = ccNextPOT(w);
powH = ccNextPOT(h);
}
data = malloc((int)(powW * powH * 4));
CC_BREAK_IF(! data);
memset(data, 0, (int)(powW * powH * 4));
m_ePixelFormat = eFormat;
m_pTexture = new CCTexture2D();
if (m_pTexture)
{
m_pTexture->initWithData(data, (CCTexture2DPixelFormat)m_ePixelFormat, powW, powH, CCSizeMake((float)w, (float)h));
}
else
{
break;
}
GLint oldRBO;
glGetIntegerv(GL_RENDERBUFFER_BINDING, &oldRBO);
if (CCConfiguration::sharedConfiguration()->checkForGLExtension("GL_QCOM"))
{
m_pTextureCopy = new CCTexture2D();
if (m_pTextureCopy)
{
m_pTextureCopy->initWithData(data, (CCTexture2DPixelFormat)m_ePixelFormat, powW, powH, CCSizeMake((float)w, (float)h));
}
else
{
break;
}
}
// generate FBO
glGenFramebuffers(1, &m_uFBO);
glBindFramebuffer(GL_FRAMEBUFFER, m_uFBO);
// associate texture with FBO
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_pTexture->getName(), 0);
if (uDepthStencilFormat != 0)
{
//create and attach depth buffer
glGenRenderbuffers(1, &m_uDepthRenderBufffer);
glBindRenderbuffer(GL_RENDERBUFFER, m_uDepthRenderBufffer);
glRenderbufferStorage(GL_RENDERBUFFER, uDepthStencilFormat, (GLsizei)powW, (GLsizei)powH);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_uDepthRenderBufffer);
// if depth format is the one with stencil part, bind same render buffer as stencil attachment
if (uDepthStencilFormat == GL_DEPTH24_STENCIL8)
{
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_uDepthRenderBufffer);
}
}
// check if it worked (probably worth doing :) )
CCAssert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE, "Could not attach texture to framebuffer");
m_pTexture->setAliasTexParameters();
// retained
setSprite(CCSprite::createWithTexture(m_pTexture));
m_pTexture->release();
m_pSprite->setScaleY(-1);
ccBlendFunc tBlendFunc = {GL_ONE, GL_ONE_MINUS_SRC_ALPHA };
m_pSprite->setBlendFunc(tBlendFunc);
glBindRenderbuffer(GL_RENDERBUFFER, oldRBO);
glBindFramebuffer(GL_FRAMEBUFFER, m_nOldFBO);
// Diabled by default.
m_bAutoDraw = false;
// add sprite for backward compatibility
addChild(m_pSprite);
bRet = true;
} while (0);
CC_SAFE_FREE(data);
return bRet;
}
/* initialise secondary framebuffer. this will just allow us to render our main
scene to a texture instead of directly to the screen. returns false if something
went wrong in the framebuffer creation */
bool init_fb () {
glGenFramebuffers (1, &g_fb);
/* create the texture that will be attached to the fb. should be the same
dimensions as the viewport */
glGenTextures (1, &g_fb_tex);
glBindTexture (GL_TEXTURE_2D, g_fb_tex);
glTexImage2D (
GL_TEXTURE_2D,
0,
GL_RGBA,
g_gl_width,
g_gl_height,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
NULL
);
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
/* attach the texture to the framebuffer */
glBindFramebuffer (GL_FRAMEBUFFER, g_fb);
glFramebufferTexture2D (
GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_fb_tex, 0
);
/* create a renderbuffer which allows depth-testing in the framebuffer */
GLuint rb = 0;
glGenRenderbuffers (1, &rb);
glBindRenderbuffer (GL_RENDERBUFFER, rb);
glRenderbufferStorage (
GL_RENDERBUFFER, GL_DEPTH_COMPONENT, g_gl_width, g_gl_height
);
/* attach renderbuffer to framebuffer */
glFramebufferRenderbuffer (
GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb
);
/* tell the framebuffer to expect a colour output attachment (our texture) */
GLenum draw_bufs[] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers (1, draw_bufs);
/* validate the framebuffer - an 'incomplete' error tells us if an invalid
image format is attached or if the glDrawBuffers information is invalid */
GLenum status = glCheckFramebufferStatus (GL_FRAMEBUFFER);
if (GL_FRAMEBUFFER_COMPLETE != status) {
fprintf (stderr, "ERROR: incomplete framebuffer\n");
if (GL_FRAMEBUFFER_UNDEFINED == status) {
fprintf (stderr, "GL_FRAMEBUFFER_UNDEFINED\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT == status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT == status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER == status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER== status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\n");
} else if (GL_FRAMEBUFFER_UNSUPPORTED == status) {
fprintf (stderr, "GL_FRAMEBUFFER_UNSUPPORTED\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE == status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\n");
} else if (GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS == status) {
fprintf (stderr, "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\n");
} else {
fprintf (stderr, "unspecified error\n");
}
return false;
}
/* re-bind the default framebuffer as a safe precaution */
glBindFramebuffer (GL_FRAMEBUFFER, 0);
return true;
}
bool RenderTexture::initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat format, GLuint depthStencilFormat)
{
CCASSERT(format != Texture2D::PixelFormat::A8, "only RGB and RGBA formats are valid for a render texture");
bool ret = false;
void *data = nullptr;
do
{
_fullRect = _rtTextureRect = Rect(0,0,w,h);
//Size size = Director::getInstance()->getWinSizeInPixels();
//_fullviewPort = Rect(0,0,size.width,size.height);
w = (int)(w * CC_CONTENT_SCALE_FACTOR());
h = (int)(h * CC_CONTENT_SCALE_FACTOR());
_fullviewPort = Rect(0,0,w,h);
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_oldFBO);
// textures must be power of two squared
int powW = 0;
int powH = 0;
if (Configuration::getInstance()->supportsNPOT())
{
powW = w;
powH = h;
}
else
{
powW = ccNextPOT(w);
powH = ccNextPOT(h);
}
auto dataLen = powW * powH * 4;
data = malloc(dataLen);
CC_BREAK_IF(! data);
memset(data, 0, dataLen);
_pixelFormat = format;
_texture = new Texture2D();
if (_texture)
{
_texture->initWithData(data, dataLen, (Texture2D::PixelFormat)_pixelFormat, powW, powH, Size((float)w, (float)h));
}
else
{
break;
}
GLint oldRBO;
glGetIntegerv(GL_RENDERBUFFER_BINDING, &oldRBO);
if (Configuration::getInstance()->checkForGLExtension("GL_QCOM"))
{
_textureCopy = new Texture2D();
if (_textureCopy)
{
_textureCopy->initWithData(data, dataLen, (Texture2D::PixelFormat)_pixelFormat, powW, powH, Size((float)w, (float)h));
}
else
{
break;
}
}
// generate FBO
glGenFramebuffers(1, &_FBO);
glBindFramebuffer(GL_FRAMEBUFFER, _FBO);
// associate texture with FBO
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _texture->getName(), 0);
if (depthStencilFormat != 0)
{
//create and attach depth buffer
glGenRenderbuffers(1, &_depthRenderBufffer);
glBindRenderbuffer(GL_RENDERBUFFER, _depthRenderBufffer);
glRenderbufferStorage(GL_RENDERBUFFER, depthStencilFormat, (GLsizei)powW, (GLsizei)powH);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _depthRenderBufffer);
// if depth format is the one with stencil part, bind same render buffer as stencil attachment
if (depthStencilFormat == GL_DEPTH24_STENCIL8)
{
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _depthRenderBufffer);
}
}
// check if it worked (probably worth doing :) )
CCASSERT(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE, "Could not attach texture to framebuffer");
_texture->setAliasTexParameters();
// retained
setSprite(Sprite::createWithTexture(_texture));
_texture->release();
_sprite->setFlippedY(true);
_sprite->setBlendFunc( BlendFunc::ALPHA_PREMULTIPLIED );
glBindRenderbuffer(GL_RENDERBUFFER, oldRBO);
glBindFramebuffer(GL_FRAMEBUFFER, _oldFBO);
// Diabled by default.
_autoDraw = false;
// add sprite for backward compatibility
addChild(_sprite);
ret = true;
} while (0);
CC_SAFE_FREE(data);
return ret;
}