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