void GLState::glsGenFramebuffers(GLsizei n, GLuint* ids) {
glGenFramebuffers(n, ids);
ERROR_CHECK;
}
// 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;
}
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;
}
GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
: m_currentWidth(0)
, m_currentHeight(0)
, m_compiler(isGLES2Compliant() ? SH_ESSL_OUTPUT : SH_GLSL_OUTPUT)
, m_attrs(attrs)
, m_renderStyle(renderStyle)
, m_texture(0)
, m_compositorTexture(0)
, m_fbo(0)
#if USE(OPENGL_ES_2)
, m_depthBuffer(0)
, m_stencilBuffer(0)
#endif
, m_depthStencilBuffer(0)
, m_layerComposited(false)
, m_internalColorFormat(0)
, m_multisampleFBO(0)
, m_multisampleDepthStencilBuffer(0)
, m_multisampleColorBuffer(0)
, m_private(GraphicsContext3DPrivate::create(this, hostWindow))
{
if (!m_private)
return;
validateAttributes();
if (renderStyle == RenderOffscreen) {
// Create buffers for the canvas FBO.
glGenFramebuffers(1, &m_fbo);
// Create a texture to render into.
glGenTextures(1, &m_texture);
glBindTexture(GraphicsContext3D::TEXTURE_2D, m_texture);
glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
// Create a multisample FBO.
if (m_attrs.antialias) {
glGenFramebuffers(1, &m_multisampleFBO);
glBindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
m_state.boundFBO = m_multisampleFBO;
glGenRenderbuffers(1, &m_multisampleColorBuffer);
if (m_attrs.stencil || m_attrs.depth)
glGenRenderbuffers(1, &m_multisampleDepthStencilBuffer);
} else {
// Bind canvas FBO.
glBindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
m_state.boundFBO = m_fbo;
#if USE(OPENGL_ES_2)
if (m_attrs.depth)
glGenRenderbuffers(1, &m_depthBuffer);
if (m_attrs.stencil)
glGenRenderbuffers(1, &m_stencilBuffer);
#endif
if (m_attrs.stencil || m_attrs.depth)
glGenRenderbuffers(1, &m_depthStencilBuffer);
}
}
// ANGLE initialization.
ShBuiltInResources ANGLEResources;
ShInitBuiltInResources(&ANGLEResources);
getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &ANGLEResources.MaxVertexAttribs);
getIntegerv(GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS, &ANGLEResources.MaxVertexUniformVectors);
getIntegerv(GraphicsContext3D::MAX_VARYING_VECTORS, &ANGLEResources.MaxVaryingVectors);
getIntegerv(GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxVertexTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxCombinedTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS, &ANGLEResources.MaxFragmentUniformVectors);
// Always set to 1 for OpenGL ES.
ANGLEResources.MaxDrawBuffers = 1;
GC3Dint range[2], precision;
getShaderPrecisionFormat(GraphicsContext3D::FRAGMENT_SHADER, GraphicsContext3D::HIGH_FLOAT, range, &precision);
ANGLEResources.FragmentPrecisionHigh = (range[0] || range[1] || precision);
m_compiler.setResources(ANGLEResources);
#if !USE(OPENGL_ES_2)
glEnable(GL_POINT_SPRITE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
#endif
if (renderStyle != RenderToCurrentGLContext)
glClearColor(0.0, 0.0, 0.0, 0.0);
}
/**
* 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;
}
GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool)
: m_currentWidth(0)
, m_currentHeight(0)
, m_attrs(attrs)
, m_texture(0)
, m_compositorTexture(0)
, m_fbo(0)
#if defined(QT_OPENGL_ES_2)
, m_depthBuffer(0)
, m_stencilBuffer(0)
#else
, m_depthStencilBuffer(0)
#endif
, m_layerComposited(false)
, m_internalColorFormat(0)
, m_boundFBO(0)
, m_activeTexture(GL_TEXTURE0)
, m_boundTexture0(0)
, m_multisampleFBO(0)
, m_multisampleDepthStencilBuffer(0)
, m_multisampleColorBuffer(0)
, m_private(adoptPtr(new GraphicsContext3DPrivate(this, hostWindow)))
{
#if !defined(QT_OPENGL_ES_2)
validateAttributes();
#endif
if (!m_private->m_surface) {
LOG_ERROR("GraphicsContext3D: QGLWidget initialization failed.");
m_private = nullptr;
return;
}
static bool initialized = false;
static bool success = true;
if (!initialized) {
success = initializeOpenGLShims();
initialized = true;
}
if (!success) {
m_private = nullptr;
return;
}
// Create buffers for the canvas FBO.
glGenFramebuffers(/* count */ 1, &m_fbo);
glGenTextures(1, &m_texture);
glBindTexture(GraphicsContext3D::TEXTURE_2D, m_texture);
glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
// Create a multisample FBO.
if (m_attrs.antialias) {
glGenFramebuffers(1, &m_multisampleFBO);
glBindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
m_boundFBO = m_multisampleFBO;
glGenRenderbuffers(1, &m_multisampleColorBuffer);
if (m_attrs.stencil || m_attrs.depth)
glGenRenderbuffers(1, &m_multisampleDepthStencilBuffer);
} else {
// Bind canvas FBO.
glBindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
m_boundFBO = m_fbo;
#if defined(QT_OPENGL_ES_2)
if (m_attrs.depth)
glGenRenderbuffers(1, &m_depthBuffer);
if (m_attrs.stencil)
glGenRenderbuffers(1, &m_stencilBuffer);
#else
if (m_attrs.stencil || m_attrs.depth)
glGenRenderbuffers(1, &m_depthStencilBuffer);
#endif
}
#if !defined(QT_OPENGL_ES_2)
// ANGLE initialization.
ShBuiltInResources ANGLEResources;
ShInitBuiltInResources(&ANGLEResources);
getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &ANGLEResources.MaxVertexAttribs);
getIntegerv(GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS, &ANGLEResources.MaxVertexUniformVectors);
getIntegerv(GraphicsContext3D::MAX_VARYING_VECTORS, &ANGLEResources.MaxVaryingVectors);
getIntegerv(GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxVertexTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxCombinedTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS, &ANGLEResources.MaxTextureImageUnits);
getIntegerv(GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS, &ANGLEResources.MaxFragmentUniformVectors);
// Always set to 1 for OpenGL ES.
ANGLEResources.MaxDrawBuffers = 1;
m_compiler.setResources(ANGLEResources);
glEnable(GL_POINT_SPRITE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
#endif
glClearColor(0.0, 0.0, 0.0, 0.0);
}
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);
}
void Gl_img_helper::create_frame_buffer(int count, GLuint* fb_id)
{
glGenFramebuffers(count, fb_id);
}
int
context_initialize(Context *context,
unsigned int image_width, unsigned int image_height,
unsigned int screen_width, unsigned int screen_height,
StereoPattern *pattern_base)
{
double wave_strengths[2 * 4];
int i;
StereoPattern *pattern;
/* Make sure that the context is passed */
if (!context || !pattern_base) {
return 0;
}
/* Initialise the maze */
context->maze.data = maze_create(ARGUMENT_VALUE(maze_size).width,
ARGUMENT_VALUE(maze_size).height);
if (!context->maze.data) {
return 0;
}
maze_initialize_randomized_prim(context->maze.data, NULL, NULL);
maze_door_open(context->maze.data,
0, 0,
MAZE_WALL_LEFT);
maze_door_open(context->maze.data,
context->maze.data->width - 1, context->maze.data->height - 1,
MAZE_WALL_RIGHT);
for (i = 0;
i < 4 * ARGUMENT_VALUE(maze_size).width
* ARGUMENT_VALUE(maze_size).height
* ARGUMENT_VALUE(shortcut_ratio);
i++) {
int x = rand() % ARGUMENT_VALUE(maze_size).width;
int y = rand() % ARGUMENT_VALUE(maze_size).height;
int wall = rand() % 4;
switch (wall) {
case 0:
if (x > 0) {
maze_door_open(context->maze.data, x, y, MAZE_WALL_LEFT);
}
break;
case 1:
if (x < ARGUMENT_VALUE(maze_size).width - 1) {
maze_door_open(context->maze.data, x, y, MAZE_WALL_RIGHT);
}
break;
case 2:
if (y > 0) {
maze_door_open(context->maze.data, x, y, MAZE_WALL_UP);
}
break;
case 3:
if (y < ARGUMENT_VALUE(maze_size).height - 1) {
maze_door_open(context->maze.data, x, y, MAZE_WALL_DOWN);
}
break;
}
}
/* Initialise the stereogram z-buffer */
context->stereo.zbuffer = stereo_zbuffer_create(image_width, image_height,
1);
/* Randomise the effect parameters */
for (i = 0; i < sizeof(wave_strengths) / sizeof(double); i++) {
wave_strengths[i] = WAVE_STRENGTH_BASE + WAVE_STRENGTH_EXTRA
* (double)(rand() - RAND_MAX / 2) / RAND_MAX / (i + 1);
}
/* Initialise the effect */
pattern = stereo_pattern_create(pattern_base->width, pattern_base->height);
context->stereo.effect = stereo_pattern_effect_wave(pattern,
sizeof(wave_strengths) / sizeof(double) / 2, wave_strengths,
pattern_base);
stereo_pattern_effect_apply(context->stereo.effect);
/* Initialise the stereogram image */
context->stereo.image = stereo_image_create_from_zbuffer(
context->stereo.zbuffer, pattern, ARGUMENT_VALUE(stereogram_strength),
1);
/* Automatically update the pattern every frame */
context->stereo.update_pattern = 1;
/* Initialise the OpenGL data */
context->gl.ratio = (GLfloat)screen_width / screen_height;
glGenFramebuffers(sizeof(context->gl.framebuffers) / sizeof(GLuint),
context->gl.framebuffers);
glGenRenderbuffers(sizeof(context->gl.renderbuffers) / sizeof(GLuint),
context->gl.renderbuffers);
glGenTextures(sizeof(context->gl.textures) / sizeof(GLuint),
context->gl.textures);
context->gl.render_stereo = 1;
context->gl.apply_texture = 0;
/* Specify the renderbuffer */
GLuint renderbuffer = context->gl.renderbuffers[0];
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
image_width, image_height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
/* Specify the render buffer */
GLuint framebuffer = context->gl.framebuffers[0];
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER_EXT, renderbuffer);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
/* Initialise the camera and target */
context->camera.x = context->target.x = 0.0;
context->camera.y = context->target.y = 0.5;
context->camera.vx = context->target.vx = 0.0;
context->camera.vy = context->target.vy = 0.0;
context->camera.ax = context->target.ax = 0.0;
context->camera.ay = context->target.ay = 0.0;
return 1;
}
bool CGLCG::LoadShader(const TCHAR *shaderFile)
{
CCGShader cgShader;
TCHAR shaderPath[MAX_PATH];
TCHAR tempPath[MAX_PATH];
CGprofile vertexProfile, fragmentProfile;
GLenum error;
if(!fboFunctionsLoaded) {
MessageBox(NULL, TEXT("Your OpenGL graphics driver does not support framebuffer objects.\nYou will not be able to use CG shaders in OpenGL mode."), TEXT("CG Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
cgGLDisableProfile(vertexProfile);
cgGLDisableProfile(fragmentProfile);
ClearPasses();
if (shaderFile == NULL || *shaderFile==TEXT('\0'))
return true;
lstrcpy(shaderPath,shaderFile);
for(int i=lstrlen(shaderPath); i>=0; i--){
if(IS_SLASH(shaderPath[i])){
shaderPath[i]=TEXT('\0');
break;
}
}
SetCurrentDirectory(shaderPath);
if(!cgShader.LoadShader(_tToChar(shaderFile)))
return false;
cgGLSetOptimalOptions(vertexProfile);
cgGLSetOptimalOptions(fragmentProfile);
/* insert dummy pass that will contain the original texture
*/
shaderPasses.push_back(shaderPass());
for(CCGShader::passVector::iterator it=cgShader.shaderPasses.begin();
it!=cgShader.shaderPasses.end();it++) {
shaderPass pass;
pass.scaleParams = it->scaleParams;
/* if this is the last pass (the only one that can have CG_SCALE_NONE)
and no filter has been set use the GUI setting
*/
if(pass.scaleParams.scaleTypeX==CG_SCALE_NONE && !it->filterSet) {
pass.linearFilter = GUI.BilinearFilter;
} else {
pass.linearFilter = it->linearFilter;
}
pass.frameCounterMod = it->frameCounterMod;
pass.floatFbo = it->floatFbo;
// paths in the meta file can be relative
_tfullpath(tempPath,_tFromChar(it->cgShaderFile),MAX_PATH);
char *fileContents = ReadShaderFileContents(tempPath);
if(!fileContents)
return false;
pass.cgVertexProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
vertexProfile, "main_vertex", NULL);
checkForCgError("Compiling vertex program");
pass.cgFragmentProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
fragmentProfile, "main_fragment", NULL);
checkForCgError("Compiling fragment program");
delete [] fileContents;
if(!pass.cgVertexProgram || !pass.cgFragmentProgram) {
return false;
}
cgGLLoadProgram(pass.cgVertexProgram);
cgGLLoadProgram(pass.cgFragmentProgram);
/* generate framebuffer and texture for this pass and apply
default texture settings
*/
glGenFramebuffers(1,&pass.fbo);
glGenTextures(1,&pass.tex);
glBindTexture(GL_TEXTURE_2D,pass.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
shaderPasses.push_back(pass);
}
for(std::vector<CCGShader::lookupTexture>::iterator it=cgShader.lookupTextures.begin();it!=cgShader.lookupTextures.end();it++) {
lookupTexture tex;
strcpy(tex.id,it->id);
/* generate texture for the lut and apply specified filter setting
*/
glGenTextures(1,&tex.tex);
glBindTexture(GL_TEXTURE_2D,tex.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
_tfullpath(tempPath,_tFromChar(it->texturePath),MAX_PATH);
// simple file extension png/tga decision
int strLen = strlen(it->texturePath);
if(strLen>4) {
if(!strcasecmp(&it->texturePath[strLen-4],".png")) {
int width, height;
bool hasAlpha;
GLubyte *texData;
if(loadPngImage(tempPath,width,height,hasAlpha,&texData)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
glTexImage2D(GL_TEXTURE_2D, 0, hasAlpha ? 4 : 3, width,
height, 0, hasAlpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, texData);
free(texData);
}
} else if(!strcasecmp(&it->texturePath[strLen-4],".tga")) {
STGA stga;
if(loadTGA(tempPath,stga)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, stga.width);
glTexImage2D(GL_TEXTURE_2D, 0, 4, stga.width,
stga.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, stga.data);
}
}
}
lookupTextures.push_back(tex);
}
/* enable texture unit 1 for the lookup textures
*/
glClientActiveTexture(GL_TEXTURE1);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2,GL_FLOAT,0,lut_coords);
glClientActiveTexture(GL_TEXTURE0);
/* generate textures and set default values for the pref-filled PREV deque.
*/
for(int i=0;i<prevPasses.size();i++) {
glGenTextures(1,&prevPasses[i].tex);
glBindTexture(GL_TEXTURE_2D,prevPasses[i].tex);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,512,512,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,NULL);
glBindTexture(GL_TEXTURE_2D,0);
prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = 0;
memset(prevPasses[i].texCoords,0,sizeof(prevPasses[i].texCoords));
}
shaderLoaded = true;
return 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;
}
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;
}
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;
}
}
}
///////////////////////////////////////////////////////////////////////////////
// OpenGL related startup code is safe to put here. Load textures, etc.
void SetupRC()
{
#ifndef ANGLE
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
#endif
// Initialze Shader Manager
shaderManager.InitializeStockShaders();
glEnable(GL_DEPTH_TEST);
// Black
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
#if defined __APPLE__ || defined ANGLE
ninja.LoadFromSBM("ninja.sbm",
GLT_ATTRIBUTE_VERTEX,
GLT_ATTRIBUTE_NORMAL,
GLT_ATTRIBUTE_TEXTURE0);
#else
ninja.LoadFromSBM("../../../Src/Models/Ninja/ninja.sbm",
GLT_ATTRIBUTE_VERTEX,
GLT_ATTRIBUTE_NORMAL,
GLT_ATTRIBUTE_TEXTURE0);
#endif
gltMakeTorus(torusBatch, 0.4f, 0.15f, 35, 35);
gltMakeSphere(sphereBatch, 0.1f, 26, 13);
GLfloat alpha = 0.25f;
floorBatch.Begin(GL_TRIANGLE_FAN, 4, 1);
floorBatch.Color4f(0.0f, 1.0f, 0.0f, alpha);
floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
floorBatch.Normal3f(0.0, 1.0f, 0.0f);
floorBatch.Vertex3f(-20.0f, -0.41f, 20.0f);
floorBatch.Color4f(0.0f, 1.0f, 0.0f, alpha);
floorBatch.MultiTexCoord2f(0, 10.0f, 0.0f);
floorBatch.Normal3f(0.0, 1.0f, 0.0f);
floorBatch.Vertex3f(20.0f, -0.41f, 20.0f);
floorBatch.Color4f(0.0f, 1.0f, 0.0f, alpha);
floorBatch.MultiTexCoord2f(0, 10.0f, 10.0f);
floorBatch.Normal3f(0.0, 1.0f, 0.0f);
floorBatch.Vertex3f(20.0f, -0.41f, -20.0f);
floorBatch.Color4f(0.0f, 1.0f, 0.0f, alpha);
floorBatch.MultiTexCoord2f(0, 0.0f, 10.0f);
floorBatch.Normal3f(0.0, 1.0f, 0.0f);
floorBatch.Vertex3f(-20.0f, -0.41f, -20.0f);
floorBatch.End();
glGenTextures(1, textures);
glBindTexture(GL_TEXTURE_2D, textures[0]);
LoadBMPTexture("marble.bmp", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_REPEAT);
glGenTextures(1, ninjaTex);
glBindTexture(GL_TEXTURE_2D, ninjaTex[0]);
#if defined __APPLE__
LoadBMPTexture("NinjaComp.bmp", GL_LINEAR, GL_LINEAR, GL_CLAMP);
#elif defined ANGLE
LoadBMPTexture("NinjaComp.bmp", GL_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE);
#else
LoadBMPTexture("../../../Src/Models/Ninja/NinjaComp.bmp", GL_LINEAR, GL_LINEAR, GL_CLAMP);
#endif
glGenFramebuffers(1,&fboName);
// Create depth renderbuffer
glGenRenderbuffers(1, &depthBufferName);
glBindRenderbuffer(GL_RENDERBUFFER, depthBufferName);
#ifndef ANGLE
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, screenWidth, screenHeight);
#else
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, screenWidth, screenHeight);
#endif
// Create 3 color renderbuffers
glGenRenderbuffers(3, renderBufferNames);
glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[0]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight);
glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[1]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight);
glBindRenderbuffer(GL_RENDERBUFFER, renderBufferNames[2]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, screenWidth, screenHeight);
// Attach all 4 renderbuffers to FBO
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboName);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBufferName);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderBufferNames[0]);
#ifndef OPENGL_ES
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, renderBufferNames[1]);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_RENDERBUFFER, renderBufferNames[2]);
#endif
// See bind frag location in Chapter 9
processProg = gltLoadShaderPairWithAttributes("multibuffer.vs", "multibuffer_frag_location.fs", 3,
GLT_ATTRIBUTE_VERTEX, "vVertex",
GLT_ATTRIBUTE_NORMAL, "vNormal",
GLT_ATTRIBUTE_TEXTURE0, "texCoord0");
#ifndef OPENGL_ES
glBindFragDataLocation(processProg, 0, "oStraightColor");
glBindFragDataLocation(processProg, 1, "oGreyscale");
glBindFragDataLocation(processProg, 2, "oLumAdjColor");
#endif
glLinkProgram(processProg);
#ifndef OPENGL_ES
// Create 3 new buffer objects
glGenBuffers(3,texBO);
glGenTextures(1, &texBOTexture);
int count = 0;
float* fileData = 0;
// Load first texBO with a tangent-like curve, 1024 values
fileData = LoadFloatData("LumTan.data", &count);
if (count > 0)
{
glBindBuffer(GL_TEXTURE_BUFFER_ARB, texBO[0]);
glBufferData(GL_TEXTURE_BUFFER_ARB, sizeof(float)*count, fileData, GL_STATIC_DRAW);
delete fileData;
}
// Load second texBO with a sine-like curve, 1024 values
fileData = LoadFloatData("LumSin.data", &count);
if (count > 0)
{
glBindBuffer(GL_TEXTURE_BUFFER_ARB, texBO[1]);
glBufferData(GL_TEXTURE_BUFFER_ARB, sizeof(float)*count, fileData, GL_STATIC_DRAW);
delete fileData;
}
// Load third texBO with a linear curve, 1024 values
fileData = LoadFloatData("LumLinear.data", &count);
if (count > 0)
{
glBindBuffer(GL_TEXTURE_BUFFER_ARB, texBO[2]);
glBufferData(GL_TEXTURE_BUFFER_ARB, sizeof(float)*count, fileData, GL_STATIC_DRAW);
delete fileData;
}
// Load the Tan ramp first
glBindBuffer(GL_TEXTURE_BUFFER_ARB, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_BUFFER_ARB, texBOTexture);
glTexBufferARB(GL_TEXTURE_BUFFER_ARB, GL_R32F, texBO[0]);
#endif
glActiveTexture(GL_TEXTURE0);
// Reset framebuffer binding
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
// Make sure all went well
gltCheckErrors();
}
bool LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, bool depth, bool stencil, LLTexUnit::eTextureType usage, bool use_fbo, U32 samples )
{
release();
stop_glerror();
if (!gGLManager.mHasFramebufferMultisample || !gGLManager.mHasFramebufferObject || !(sUseFBO || use_fbo))
return false;
if(color_fmt != GL_RGBA)
{
llwarns << "Unsupported color format: " << color_fmt << llendl;
return false;
}
//Restrict to valid sample count
{
mSamples = samples;
//mSamples = llmin(mSamples, (U32)4); //Cap to prevent memory bloat.
mSamples = llmin(mSamples, (U32) gGLManager.mMaxSamples);
}
if (mSamples <= 1)
return false;
mResX = resx;
mResY = resy;
mUsage = usage;
mUseDepth = depth;
mStencil = stencil;
mColorFormat = color_fmt;
{
if (depth)
{
stop_glerror();
if(!allocateDepth())
{
release();
return false;
}
stop_glerror();
}
glGenFramebuffers(1, (GLuint *) &mFBO);
glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
stop_glerror();
clear_glerror();
if (mDepth)
{
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepth);
if (mStencil)
{
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, mDepth);
}
}
stop_glerror();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
stop_glerror();
}
return addColorAttachment(color_fmt);
}
/**
* Function for initialization.
*/
GLUSboolean init(GLUSvoid)
{
// Points for referencing each texel
GLfloat points[PARTICLES_LOOKUP_WIDTH*PARTICLES_LOOKUP_WIDTH*2];
// Initial particle data
GLfloat particle[PARTICLES_LOOKUP_WIDTH*PARTICLES_LOOKUP_WIDTH*4];
GLUStgaimage image;
GLUStextfile vertexSource;
GLUStextfile fragmentSource;
GLuint x, y;
// Create points which are refernceing on the different texels
for (y = 0; y < PARTICLES_LOOKUP_WIDTH; y++)
{
for (x = 0; x < PARTICLES_LOOKUP_WIDTH; x++)
{
points[x*2+0 + y*PARTICLES_LOOKUP_WIDTH*2] = (GLfloat)x/(GLfloat)PARTICLES_LOOKUP_WIDTH;
points[x*2+1 + y*PARTICLES_LOOKUP_WIDTH*2] = (GLfloat)y/(GLfloat)PARTICLES_LOOKUP_WIDTH;
}
}
// Create the initial particles data
for (y = 0; y < PARTICLES_LOOKUP_WIDTH; y++)
{
for (x = 0; x < PARTICLES_LOOKUP_WIDTH; x++)
{
particle[x*4+0 + y*PARTICLES_LOOKUP_WIDTH*4] = 0.0f;
particle[x*4+1 + y*PARTICLES_LOOKUP_WIDTH*4] = 0.0f;
particle[x*4+2 + y*PARTICLES_LOOKUP_WIDTH*4] = 0.0f;
particle[x*4+3 + y*PARTICLES_LOOKUP_WIDTH*4] = (rand()%101)/100.0f;
}
}
// Load the source of the vertex shader.
glusLoadTextFile("../Example08/Vertex.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../Example08/Fragment.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_program, (const GLUSchar**)&vertexSource.text, 0, (const GLUSchar**)&fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// ToDo:
glGenVertexArrays(1, &g_vao);
// ToDo:
glBindVertexArray(g_vao);
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_projectionLocation = glGetUniformLocation(g_program.program, "projectionMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_modelViewLocation = glGetUniformLocation(g_program.program, "modelViewMatrix");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_textureLocation = glGetUniformLocation(g_program.program, "firstTexture");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_lookuptextureLocation = glGetUniformLocation(g_program.program, "readTexture");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocation = glGetAttribLocation(g_program.program, "vertex");
// ToDo:
glBindFragDataLocation(g_program.program, 0, "fragColor");
// Load the source of the vertex shader.
glusLoadTextFile("../Example08/UpdatePoints.vs", &vertexSource);
// Load the source of the fragment shader.
glusLoadTextFile("../Example08/UpdatePoints.fs", &fragmentSource);
// Build and ...
glusBuildProgram(&g_programUpdate, (const GLUSchar**)&vertexSource.text, 0, (const GLUSchar**)&fragmentSource.text);
// Destroy the text resource
glusDestroyTextFile(&vertexSource);
// Destroy the text resource
glusDestroyTextFile(&fragmentSource);
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_lookuptextureLocationUpdate = glGetUniformLocation(g_programUpdate.program, "readTexture");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_sizeLocation = glGetUniformLocation(g_programUpdate.program, "size");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
g_timeLocation = glGetUniformLocation(g_programUpdate.program, "time");
// http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
g_vertexLocationUpdate = glGetAttribLocation(g_programUpdate.program, "vertex");
// ToDo:
glBindFragDataLocation(g_programUpdate.program, 0, "fragParticle");
// http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
glGenBuffers(1, &g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
glBufferData(GL_ARRAY_BUFFER, PARTICLES_LOOKUP_WIDTH*PARTICLES_LOOKUP_WIDTH*2*sizeof(GLfloat), (GLfloat*)points, GL_STATIC_DRAW);
glusLoadTgaImage("particle.tga", &image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html
glGenTextures(1, &g_texture);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, g_texture);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_2D, 0, image.format, image.width, image.height, 0, image.format, GL_UNSIGNED_BYTE, image.data);
glusDestroyTgaImage(&image);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/gentextures.html
glGenTextures(2, g_lookuptexture);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, g_lookuptexture[0]);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, PARTICLES_LOOKUP_WIDTH, PARTICLES_LOOKUP_WIDTH, 0, GL_RGBA, GL_FLOAT, particle);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, g_lookuptexture[1]);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/teximage2d.html
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, PARTICLES_LOOKUP_WIDTH, PARTICLES_LOOKUP_WIDTH, 0, GL_RGBA, GL_FLOAT, particle);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/texparameter.html
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// ToDo:
glGenFramebuffers(2, g_lookupframebuffer);
// ToDo:
glBindFramebuffer(GL_FRAMEBUFFER, g_lookupframebuffer[0]);
// ToDo:
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_lookuptexture[0], 0);
// ToDo:
glBindFramebuffer(GL_FRAMEBUFFER, g_lookupframebuffer[1]);
// ToDo:
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_lookuptexture[1], 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// Calculate the view matrix ...
glusLookAtf(g_modelView, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocation);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1i(g_textureLocation, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glActiveTexture.xml
glActiveTexture(GL_TEXTURE0);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/bindtexture.html
glBindTexture(GL_TEXTURE_2D, g_texture);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_programUpdate.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniform1f(g_sizeLocation, (GLfloat)PARTICLES_LOOKUP_WIDTH);
// http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
// http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
glVertexAttribPointer(g_vertexLocationUpdate, 2, GL_FLOAT, GL_FALSE, 0, 0);
// http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
glEnableVertexAttribArray(g_vertexLocationUpdate);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_program.program);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clearcolor.html
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
return GLUS_TRUE;
}
FrameBuffer::FrameBuffer() :
allocated(true)
{
glAssert(glGenFramebuffers(1, &fbo));
}
void startup() override
{
loadShaders();
glGenFramebuffers(1, &_renderFBO);
glBindFramebuffer(GL_FRAMEBUFFER, _renderFBO);
glGenTextures(3, _FBOTextures);
glBindTexture(GL_TEXTURE_2D, _FBOTextures[0]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGB16F, 2048, 2048);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, _FBOTextures[1]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, 2048, 2048);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, _FBOTextures[2]);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT32F, 2048, 2048);
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);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _FBOTextures[0], 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, _FBOTextures[1], 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, _FBOTextures[2], 0);
static const GLenum drawBuffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
glDrawBuffers(2, drawBuffers);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glGenVertexArrays(1, &_quadVAO);
glBindVertexArray(_quadVAO);
_object.load("media/objects/dragon.sbm");
_cube.load("media/objects/cube.sbm");
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
SAMPLE_POINTS pointData;
for (int i = 0; i < 256; i++)
{
do
{
pointData.Point[i][0] = GetRandomFloat() * 2.0f - 1.0f;
pointData.Point[i][1] = GetRandomFloat() * 2.0f - 1.0f;
pointData.Point[i][2] = GetRandomFloat();
pointData.Point[i][3] = 0.0f;
}
while (length(pointData.Point[i]) > 1.0f);
normalize(pointData.Point[i]);
}
for (int i = 0; i < 256; i++)
{
pointData.RandomVectors[i][0] = GetRandomFloat();
pointData.RandomVectors[i][1] = GetRandomFloat();
pointData.RandomVectors[i][2] = GetRandomFloat();
pointData.RandomVectors[i][3] = GetRandomFloat();
}
glGenBuffers(1, &_pointsBuffer);
glBindBuffer(GL_UNIFORM_BUFFER, _pointsBuffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(SAMPLE_POINTS), &pointData, GL_STATIC_DRAW);
}
int surface_create_msaa(int width, int height, int samples)
{
if (!GLEW_ARB_framebuffer_object)
{
return -1;
}
GLuint fbo;
size_t id,
w = (int)width,
h = (int)height; //get the integer width and height, and prepare to search for an id
if (enigma::surface_max==0) {
enigma::surface_array=new enigma::surface*[1];
enigma::surface_max=1;
}
for (id=0; enigma::surface_array[id]!=NULL; id++)
{
if (id+1 >= enigma::surface_max)
{
enigma::surface **oldarray=enigma::surface_array;
enigma::surface_array=new enigma::surface*[enigma::surface_max+1];
for (size_t i=0; i<enigma::surface_max; i++)
enigma::surface_array[i]=oldarray[i];
enigma::surface_array[enigma::surface_max]=NULL;
enigma::surface_max++;
delete[] oldarray;
}
}
enigma::surface_array[id] = new enigma::surface;
enigma::surface_array[id]->width = w;
enigma::surface_array[id]->height = h;
int texture = enigma::graphics_create_texture(w,h,w,h,0,false);
glGenFramebuffers(1, &fbo);
glPushAttrib(GL_TEXTURE_BIT);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureStructs[texture]->gltex);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_RGBA, w, h, false);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, textureStructs[texture]->gltex, 0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glClearColor(1,1,1,0);
glClear(GL_COLOR_BUFFER_BIT);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, enigma::bound_framebuffer);
glPopAttrib();
enigma::surface_array[id]->tex = texture;
enigma::surface_array[id]->fbo = fbo;
return id;
}
static struct gears *
gears_create(struct display *display)
{
const int width = 450, height = 500;
struct gears *gears;
int i;
gears = malloc(sizeof *gears);
memset(gears, 0, sizeof *gears);
gears->d = display;
gears->window = window_create(display, "Wayland Gears", width, height);
gears->display = display_get_egl_display(gears->d);
if (gears->display == NULL)
die("failed to create egl display\n");
eglBindAPI(EGL_OPENGL_API);
gears->context = eglCreateContext(gears->display,
NULL, EGL_NO_CONTEXT, NULL);
if (gears->context == NULL)
die("failed to create context\n");
if (!eglMakeCurrent(gears->display, NULL, NULL, gears->context))
die("faile to make context current\n");
glGenFramebuffers(1, &gears->fbo);
glBindFramebuffer(GL_FRAMEBUFFER_EXT, gears->fbo);
glGenRenderbuffers(2, gears->color_rbo);
glGenRenderbuffers(1, &gears->depth_rbo);
glBindRenderbuffer(GL_RENDERBUFFER_EXT, gears->depth_rbo);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER_EXT,
GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT,
gears->depth_rbo);
for (i = 0; i < 3; i++) {
gears->gear_list[i] = glGenLists(1);
glNewList(gears->gear_list[i], GL_COMPILE);
make_gear(&gear_templates[i]);
glEndList();
}
glEnable(GL_NORMALIZE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 200.0);
glMatrixMode(GL_MODELVIEW);
glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glClearColor(0, 0, 0, 0.92);
window_set_user_data(gears->window, gears);
window_set_resize_handler(gears->window, resize_handler);
window_set_keyboard_focus_handler(gears->window, keyboard_focus_handler);
window_set_redraw_handler(gears->window, redraw_handler);
draw_gears(gears);
wl_display_frame_callback(display_get_display(gears->d),
frame_callback, gears);
return gears;
}
void Framebuffer2D::Create()
{
GLCall(glGenFramebuffers(1, &m_RendererID));
GLCall(glBindFramebuffer(GL_FRAMEBUFFER, m_RendererID));
}
static void
Init(void)
{
const GLubyte *extensions;
GLboolean hasDebugExtension;
extensions = glGetString(GL_EXTENSIONS);
checkGlError("glGetString(GL_EXTENSIONS)");
hasDebugExtension = checkExtension(debugExtensionString, extensions);
if (GLEW_VERSION_3_0) {
GLboolean hasDebugExtension3 = GL_FALSE;
GLint i;
GLint num_extensions = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
checkGlError("glGetIntegerv(GL_NUM_EXTENSIONS)");
for (i = 0; i < num_extensions; ++i) {
const char *extension;
extension = (const char *)glGetStringi(GL_EXTENSIONS, i);
checkGlError("glGetStringi(GL_EXTENSIONS, i)");
if (strlen(extension) == 0) {
fprintf(stderr, "error: glGetStringi returned empty string\n");
exit(1);
}
if (strcmp(extension, debugExtensionString) == 0) {
hasDebugExtension3 = GL_TRUE;
}
}
if (hasDebugExtension != hasDebugExtension3) {
fprintf(stderr, "error: %s not consistently supported by GL3\n", debugExtensionString);
exit(1);
}
}
glewInit();
if (hasDebugExtension != glewIsSupported(debugExtensionString)) {
fprintf(stderr, "error: %s not consistently supported by GLEW\n", debugExtensionString);
exit(1);
}
if (hasDebugExtension) {
switch (debugExtension) {
case KHR_DEBUG:
debugMessageInsert = khrDebugMessageInsert;
pushDebugGroup = khrPushDebugGroup;
popDebugGroup = khrPopDebugGroup;
objectLabel = glObjectLabel;
getObjectLabel = glGetObjectLabel;
break;
case ARB_DEBUG_OUTPUT:
debugMessageInsert = arbDebugMessageInsert;
break;
case AMD_DEBUG_OUTPUT:
debugMessageInsert = amdDebugMessageInsert;
break;
case EXT_DEBUG_MARKER:
debugMessageInsert = extDebugMessageInsert;
pushDebugGroup = extPushDebugGroup;
popDebugGroup = extPopDebugGroup;
break;
}
} else {
fprintf(stderr, "warning: %s not supported\n", debugExtensionString);
}
debugMessageInsert(-1, __FUNCTION__);
pushDebugGroup(-1, __FUNCTION__);
glClearColor(0.3, 0.1, 0.3, 1.0);
popDebugGroup();
// texture label
GLuint texture = 0;
glGenTextures(1, &texture);
objectLabel(GL_TEXTURE, texture, -1, "texture");
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
// framebuffer color attachment label
GLuint framebuffer = 0;
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
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);
}
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;
}
}
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 InitOpenGL()
{
glewInit();
//////////////////////////////////////////////////////
//initialize and load shader
GLuint new_shader = InitShader(vertex_shader.c_str(), fragment_shader.c_str());
if (new_shader == -1)
{
glClearColor(1.0f, 0.0f, 1.0f, 0.0f);
}
else
{
glClearColor(0.35f, 0.35f, 0.35f, 0.0f);
if (shader_program != -1)
{
glDeleteProgram(shader_program);
}
shader_program = new_shader;
}
//////////////////////////////////////////////////////
//build reflected and reflect objects
//load objects - cow, fish, sphere
cow_mesh_data = LoadMesh(cow_mesh_name);
fish_mesh_data = LoadMesh(fish_mesh_name);
sphere_mesh_data = LoadMesh(sphere_mesh_name);
//////////////////////////////////////////////////////
//create a cubemap texture object and set empty texture images
glGenTextures(1, &CubemapID);
glBindTexture(GL_TEXTURE_CUBE_MAP, CubemapID);
for (int i = 0; i < 6; i++)
{
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, cubemapsize, cubemapsize, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
}
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_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
//////////////////////////////////////////////////////
//create the depth buffer for the framebuffer object
glGenRenderbuffers(1, &RBOID);
glBindRenderbuffer(GL_RENDERBUFFER, RBOID);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, cubemapsize, cubemapsize);
//////////////////////////////////////////////////////
//create the framebuffer object and attach the cubemap faces and the depth buffer
glGenFramebuffers(1, &FBOID);
glBindFramebuffer(GL_FRAMEBUFFER, FBOID);
for (int i = 0; i < 6; i++)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, CubemapID, 0);
}
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, RBOID);
if (!CheckFramebufferStatus())
{
ExitGlut();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glEnable(GL_DEPTH_TEST);
}
void GenFramebuffers(const GLsizei N, GLuint* const Textures)
{
glGenFramebuffers(N, Textures);
}
uint FrameBuffer::generateBuffer()
{
uint buf;
glGenFramebuffers(1, &buf);
return buf;
}
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;
}
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();
}