void Scene::deferredRender() { // Requires: // + A g-buffer class to store framebuffers for each attribute; // + Code to bind each framebuffer to a separate fragdatalocation; // + A g-buffer shader program that populates the g-buffer when rendering geometry; // + A VAO for each mesh to support the g-buffer shader program; // - Deferred shading programs that take input from the g-buffer instead of the vertex shader, etc.; // Render all geometry to g-buffer: gBuffer->bind(); // TODO: Refactor enabling of framebuffer colour attachments. GLuint attachments[3] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 }; glDrawBuffers(3, attachments); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport(0, 0, camera->frameWidth, camera->frameHeight); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); drawModels(gBufferProgram, *camera); glDisable(GL_CULL_FACE); profiler.split("render g-buffer"); // Attach g-buffer uniforms to the deferred shaders: gBuffer->bindTextures(); deferredShadingProgram->use(); deferredShadingProgram->setUniform("texDepthStencil", gBuffer->textureAttachments[GL_DEPTH_STENCIL_ATTACHMENT]); deferredShadingProgram->setUniform("texNormal", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT0]); deferredShadingProgram->setUniform("texAlbedoRoughness", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT1]); deferredShadingProgram->setUniform("texEnvMapColSpecIntensity", gBuffer->textureAttachments[GL_COLOR_ATTACHMENT2]); glm::mat4 projInverse = glm::inverse(camera->proj); deferredShadingProgram->setUniform("projInverse", projInverse); glm::mat4 viewInverse = glm::inverse(camera->view); deferredShadingProgram->setUniform("viewInverse", viewInverse); deferredShadingProgram->setUniform("view", camera->view); // Clear the framebuffer: framebuffer->bind(); glClear(GL_COLOR_BUFFER_BIT); glDisable(GL_CULL_FACE); // Render the environment map: framebuffer->bind(); glViewport(0, 0, camera->frameWidth, camera->frameHeight); screen->setTexture(gBuffer->textureAttachments[GL_COLOR_ATTACHMENT2]); screen->render(); screen->removeTexture(); // Run the deferred shader over the framebuffer for each light: int lightNum = 1; for (auto light : lights) { auto sharedLight = light.lock(); if (sharedLight->enabled) { auto lightCamera = prepareShadowMap(lightNum, sharedLight); framebuffer->bind(); glViewport(0, 0, camera->frameWidth, camera->frameHeight); // glClear(GL_COLOR_BUFFER_BIT); gBuffer->bindTextures(); screen->setTexture(framebuffer->textureAttachments[GL_COLOR_ATTACHMENT0]); Model::setLightUniformsOnShaderProgram(deferredShadingProgram, sharedLight, lightCamera); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); screen->render(deferredShadingProgram); glDisable(GL_BLEND); profiler.split("deferred light ", lightNum); // // Add the light's contribution to the screen: // addFramebufferToTarget(); // Render a tiny shadow map: if (!previewOptions.disable && (sharedLight->type == scene::Light::Type::spot || sharedLight->type == scene::Light::Type::directional)) { drawShadowMapThumbnail(lightNum - 1); } profiler.split("drawShadowMapThumbnail ", lightNum); } lightNum++; } // Draw skybox and transparent meshes: // (use the depth buffer from the g-buffer) framebuffer->bind(); glViewport(0, 0, camera->frameWidth, camera->frameHeight); framebuffer->attach(gBuffer->textureAttachments[GL_DEPTH_STENCIL_ATTACHMENT], GL_TEXTURE_2D, GL_DEPTH_STENCIL_ATTACHMENT); // Draw skybox first: skyBox->draw(*camera, skyBox->environmentMapProgram); // Draw all transparent meshes: // Disable depth buffer writes (for order invariant drawing): glDepthMask(GL_FALSE); lightNum = 1; for (auto light : lights) { auto sharedLight = light.lock(); if (sharedLight->enabled) { auto lightCamera = prepareShadowMap(lightNum, sharedLight); framebuffer->bind(); glViewport(0, 0, camera->frameWidth, camera->frameHeight); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); checkForAndPrintGLError(__FILE__, __LINE__); drawModels(sharedLight, lightCamera, true, *camera); glDisable(GL_BLEND); profiler.split("transparent: light ", lightNum); } lightNum++; } // Enable depth buffer writes: glDepthMask(GL_TRUE); // Restore the framebuffer's depth attachment: framebuffer->attach(std::move(framebuffer->renderbufferAttachment)); profiler.split("deferred lighting"); if (previewOptions.disable) { addFramebufferToTarget(framebufferSize, nullptr); } else { if (!previewOptions.fullscreen) addFramebufferToTarget(framebufferSize, nullptr, 2, 0.5, 0.5); } // Render g-buffer thumbnails: if (!previewOptions.disable) drawGBufferThumbnails(); }
int main() { int retVal = -1; if (glfwInit()) { //glfwWindowHint(GLFW_DOUBLEBUFFER, GL_FALSE); glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); glfwWindowHint(GLFW_SAMPLES, 16); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glEnable(GL_MULTISAMPLE); const int initWinWidth = 640; const int initWinHeight = 480; GLFWwindow * win = glfwCreateWindow(initWinWidth, initWinHeight, "TxCube", NULL, NULL); if (win) { glfwMakeContextCurrent(win); glfwSetWindowSizeCallback(win, OnWindowSize); glfwSwapInterval(1); glewExperimental = GL_TRUE; if (glewInit() == GLEW_OK) { // workaround GLEW issue with GL_INVALID_ENUM rising just after glewInit glGetError(); GLuint vertexArrayId; glGenVertexArrays(1, &vertexArrayId); assert(!glGetError()); glBindVertexArray(vertexArrayId); assert(!glGetError()); //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); assert(!glGetError()); glEnable(GL_CULL_FACE); assert(!glGetError()); glCullFace(GL_FRONT); assert(!glGetError()); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); scene = new Scene(); scene->setViewport(initWinWidth, initWinHeight); int cnt = 0; uint64_t freq = Crosy::getPerformanceFrequency(); uint64_t ticks = Crosy::getPerformanceCounter(); while (!glfwWindowShouldClose(win)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); assert(!glGetError()); scene->draw(); glfwSwapBuffers(win); glfwPollEvents(); cnt++; Crosy::sleep(10); float timePass = float(Crosy::getPerformanceCounter() - ticks) / freq; if (timePass > 10) { float fps = cnt / timePass; const int bufSize = 256; char str[bufSize]; #ifdef _MSC_VER _snprintf(str, bufSize, "Fps: %.3f", fps); #else snprintf(str, bufSize, "Fps: %.3f", fps); #endif glfwSetWindowTitle(win, str); ticks = Crosy::getPerformanceCounter(); cnt = 0; } } retVal = 0; delete scene; } } glfwTerminate(); } return retVal; }
static void draw_scene(GLFWwindow* window, double t) { double xpos, ypos, zpos, angle_x, angle_y, angle_z; static double t_old = 0.0; float dt; mat4x4 projection; // Calculate frame-to-frame delta time dt = (float) (t - t_old); t_old = t; mat4x4_perspective(projection, 65.f * (float) M_PI / 180.f, aspect_ratio, 1.0, 60.0); glClearColor(0.1f, 0.1f, 0.1f, 1.f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadMatrixf((const GLfloat*) projection); // Setup camera glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Rotate camera angle_x = 90.0 - 10.0; angle_y = 10.0 * sin(0.3 * t); angle_z = 10.0 * t; glRotated(-angle_x, 1.0, 0.0, 0.0); glRotated(-angle_y, 0.0, 1.0, 0.0); glRotated(-angle_z, 0.0, 0.0, 1.0); // Translate camera xpos = 15.0 * sin((M_PI / 180.0) * angle_z) + 2.0 * sin((M_PI / 180.0) * 3.1 * t); ypos = -15.0 * cos((M_PI / 180.0) * angle_z) + 2.0 * cos((M_PI / 180.0) * 2.9 * t); zpos = 4.0 + 2.0 * cos((M_PI / 180.0) * 4.9 * t); glTranslated(-xpos, -ypos, -zpos); glFrontFace(GL_CCW); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); setup_lights(); glEnable(GL_LIGHTING); glEnable(GL_FOG); glFogi(GL_FOG_MODE, GL_EXP); glFogf(GL_FOG_DENSITY, 0.05f); glFogfv(GL_FOG_COLOR, fog_color); draw_floor(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(GL_TRUE); draw_fountain(); glDisable(GL_LIGHTING); glDisable(GL_FOG); // Particles must be drawn after all solid objects have been drawn draw_particles(window, t, dt); // Z-buffer not needed anymore glDisable(GL_DEPTH_TEST); }
void OpenGLState::Apply() const { // Culling if (cull.enabled != cur_state.cull.enabled) { if (cull.enabled) { glEnable(GL_CULL_FACE); } else { glDisable(GL_CULL_FACE); } } if (cull.mode != cur_state.cull.mode) { glCullFace(cull.mode); } if (cull.front_face != cur_state.cull.front_face) { glFrontFace(cull.front_face); } // Depth test if (depth.test_enabled != cur_state.depth.test_enabled) { if (depth.test_enabled) { glEnable(GL_DEPTH_TEST); } else { glDisable(GL_DEPTH_TEST); } } if (depth.test_func != cur_state.depth.test_func) { glDepthFunc(depth.test_func); } // Depth mask if (depth.write_mask != cur_state.depth.write_mask) { glDepthMask(depth.write_mask); } // Color mask if (color_mask.red_enabled != cur_state.color_mask.red_enabled || color_mask.green_enabled != cur_state.color_mask.green_enabled || color_mask.blue_enabled != cur_state.color_mask.blue_enabled || color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) { glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled, color_mask.alpha_enabled); } // Stencil test if (stencil.test_enabled != cur_state.stencil.test_enabled) { if (stencil.test_enabled) { glEnable(GL_STENCIL_TEST); } else { glDisable(GL_STENCIL_TEST); } } if (stencil.test_func != cur_state.stencil.test_func || stencil.test_ref != cur_state.stencil.test_ref || stencil.test_mask != cur_state.stencil.test_mask) { glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask); } if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail || stencil.action_depth_pass != cur_state.stencil.action_depth_pass || stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) { glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail, stencil.action_depth_pass); } // Stencil mask if (stencil.write_mask != cur_state.stencil.write_mask) { glStencilMask(stencil.write_mask); } // Blending if (blend.enabled != cur_state.blend.enabled) { if (blend.enabled) { glEnable(GL_BLEND); cur_state.logic_op = GL_COPY; glLogicOp(cur_state.logic_op); glDisable(GL_COLOR_LOGIC_OP); } else { glDisable(GL_BLEND); glEnable(GL_COLOR_LOGIC_OP); } } if (blend.color.red != cur_state.blend.color.red || blend.color.green != cur_state.blend.color.green || blend.color.blue != cur_state.blend.color.blue || blend.color.alpha != cur_state.blend.color.alpha) { glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha); } if (blend.src_rgb_func != cur_state.blend.src_rgb_func || blend.dst_rgb_func != cur_state.blend.dst_rgb_func || blend.src_a_func != cur_state.blend.src_a_func || blend.dst_a_func != cur_state.blend.dst_a_func) { glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func, blend.dst_a_func); } if (blend.rgb_equation != cur_state.blend.rgb_equation || blend.a_equation != cur_state.blend.a_equation) { glBlendEquationSeparate(blend.rgb_equation, blend.a_equation); } if (logic_op != cur_state.logic_op) { glLogicOp(logic_op); } // Textures for (unsigned i = 0; i < ARRAY_SIZE(texture_units); ++i) { if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) { glActiveTexture(GL_TEXTURE0 + i); glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d); } if (texture_units[i].sampler != cur_state.texture_units[i].sampler) { glBindSampler(i, texture_units[i].sampler); } } // Lighting LUTs for (unsigned i = 0; i < ARRAY_SIZE(lighting_luts); ++i) { if (lighting_luts[i].texture_1d != cur_state.lighting_luts[i].texture_1d) { glActiveTexture(GL_TEXTURE3 + i); glBindTexture(GL_TEXTURE_1D, lighting_luts[i].texture_1d); } } // Fog LUT if (fog_lut.texture_1d != cur_state.fog_lut.texture_1d) { glActiveTexture(GL_TEXTURE9); glBindTexture(GL_TEXTURE_1D, fog_lut.texture_1d); } // Framebuffer if (draw.read_framebuffer != cur_state.draw.read_framebuffer) { glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer); } if (draw.draw_framebuffer != cur_state.draw.draw_framebuffer) { glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw.draw_framebuffer); } // Vertex array if (draw.vertex_array != cur_state.draw.vertex_array) { glBindVertexArray(draw.vertex_array); } // Vertex buffer if (draw.vertex_buffer != cur_state.draw.vertex_buffer) { glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer); } // Uniform buffer if (draw.uniform_buffer != cur_state.draw.uniform_buffer) { glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer); } // Shader program if (draw.shader_program != cur_state.draw.shader_program) { glUseProgram(draw.shader_program); } cur_state = *this; }
//Method initializes OpenGL for rendering to a window/viewport bool engine_3d::Init() { /// We need our GLFW function pointers to be assigned, if this process fails we cannot continue if ( !glfwInit() ) { return false; } /// Here we query how much sampling is possible and set that to be used if possible GLint samples = 8; glGetIntegerv( GL_SAMPLES, &samples ); if ( samples ) { glEnable( GL_MULTISAMPLE ); } glfwWindowHint( GLFW_SAMPLES, samples ); GLFWmonitor** monitors; int count; monitors = glfwGetMonitors( &count ); const GLFWvidmode* mode = glfwGetVideoMode( glfwGetPrimaryMonitor() ); ///Create a window of a particular type switch ( winMode ) { case engine_WindowModel::FULLSCREEN: window = glfwCreateWindow( mode->width, mode->height, "Fullscreen", glfwGetPrimaryMonitor(), NULL ); screenHeight = mode->height; screenWidth = mode->width; break; case engine_WindowModel::DECORATEDWINDOW: window = glfwCreateWindow( screenWidth, screenHeight, "Decorated Window", NULL, NULL ); break; case engine_WindowModel::BORDERLESSFULLSCREEN: glfwWindowHint( GLFW_DECORATED, false ); glfwWindowHint( GLFW_RED_BITS, mode->redBits ); glfwWindowHint( GLFW_GREEN_BITS, mode->greenBits ); glfwWindowHint( GLFW_BLUE_BITS, mode->blueBits ); glfwWindowHint( GLFW_REFRESH_RATE, mode->refreshRate ); window = glfwCreateWindow( mode->width, mode->height, "Borderless Fullscreen", NULL, NULL ); screenHeight = mode->height; screenWidth = mode->width; break; } /// If creating the window failed we need to terminate if ( !window ) { glfwTerminate(); return false; } /// Associates this window with OpenGL's rendering (I believe) glfwMakeContextCurrent( window ); /// Sets our input processing function, all input will be passed to this function //glfwSetScrollCallback( window, scroll_callback ); glfwSetKeyCallback( window, key_callback ); glfwSetCursorPosCallback( window, cursor_position_callback ); glfwSetMouseButtonCallback( window, mouse_button_callback ); /// start GLEW extension handler glewExperimental = GL_TRUE; ///Initialize OpenGL functions glewInit(); const GLubyte* renderer = glGetString( GL_RENDERER ); /// get renderer string const GLubyte* version = glGetString( GL_VERSION ); /// version as a string ///oLog( Level::Info ) << "Renderer: " << renderer; ///oLog( Level::Info ) << "OpenGL version supported: " << version; projectionMatrix = glm::mat4( 1.f ); viewMatrix = glm::mat4( 1.f ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); glFrontFace( GL_CCW ); glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); ///clear colour: r,g,b,a glfwSwapInterval( 1 ); ///cap FPS currentDC = wglGetCurrentDC(); currentContext = wglGetCurrentContext(); return true; }
void templateAppDraw( void ) { glClearColor( 0.5f, 0.5f, 0.5f, 1.0f ); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); GFX_set_matrix_mode( MODELVIEW_MATRIX ); GFX_load_identity(); vec3 e = { 0.0f, -6.0f, 1.35f }, c = { 0.0f, -5.0f, 1.35f }, u = { 0.0f, 0.0f, 1.0f }; GFX_look_at( &e, &c, &u ); unsigned int i = 0; while( i != obj->n_objmesh ) { OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial; if( objmaterial->dissolve == 1.0f ) { GFX_push_matrix(); GFX_translate( obj->objmesh[ i ].location.x, obj->objmesh[ i ].location.y, obj->objmesh[ i ].location.z ); OBJ_draw_mesh( obj, i ); GFX_pop_matrix(); } ++i; } i = 0; while( i != obj->n_objmesh ) { OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial; if( !objmaterial->dissolve ) { GFX_push_matrix(); GFX_translate( obj->objmesh[ i ].location.x, obj->objmesh[ i ].location.y, obj->objmesh[ i ].location.z ); glCullFace( GL_FRONT ); OBJ_draw_mesh( obj, i ); glCullFace( GL_BACK ); OBJ_draw_mesh( obj, i ); GFX_pop_matrix(); } ++i; } glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); i = 0; while( i != obj->n_objmesh ) { OBJMATERIAL *objmaterial = obj->objmesh[ i ].objtrianglelist[ 0 ].objmaterial; if( objmaterial->dissolve > 0.0f && objmaterial->dissolve < 1.0f ) { GFX_push_matrix(); GFX_translate( obj->objmesh[ i ].location.x, obj->objmesh[ i ].location.y, obj->objmesh[ i ].location.z ); glCullFace( GL_FRONT ); OBJ_draw_mesh( obj, i ); glCullFace( GL_BACK ); OBJ_draw_mesh( obj, i ); GFX_pop_matrix(); } ++i; } glDisable( GL_BLEND ); }
void StateBlock::bindNoRestore() { CC_ASSERT(_defaultState); // Update any state that differs from _defaultState and flip _defaultState bits if ((_bits & RS_BLEND) && (_blendEnabled != _defaultState->_blendEnabled)) { if (_blendEnabled) glEnable(GL_BLEND); else glDisable(GL_BLEND); _defaultState->_blendEnabled = _blendEnabled; } if ((_bits & RS_BLEND_FUNC) && (_blendSrc != _defaultState->_blendSrc || _blendDst != _defaultState->_blendDst)) { GL::blendFunc((GLenum)_blendSrc, (GLenum)_blendDst); _defaultState->_blendSrc = _blendSrc; _defaultState->_blendDst = _blendDst; } if ((_bits & RS_CULL_FACE) && (_cullFaceEnabled != _defaultState->_cullFaceEnabled)) { if (_cullFaceEnabled) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); _defaultState->_cullFaceEnabled = _cullFaceEnabled; } if ((_bits & RS_CULL_FACE_SIDE) && (_cullFaceSide != _defaultState->_cullFaceSide)) { glCullFace((GLenum)_cullFaceSide); _defaultState->_cullFaceSide = _cullFaceSide; } if ((_bits & RS_FRONT_FACE) && (_frontFace != _defaultState->_frontFace)) { glFrontFace((GLenum)_frontFace); _defaultState->_frontFace = _frontFace; } if ((_bits & RS_DEPTH_TEST) && (_depthTestEnabled != _defaultState->_depthTestEnabled)) { if (_depthTestEnabled) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); _defaultState->_depthTestEnabled = _depthTestEnabled; } if ((_bits & RS_DEPTH_WRITE) && (_depthWriteEnabled != _defaultState->_depthWriteEnabled)) { glDepthMask(_depthWriteEnabled ? GL_TRUE : GL_FALSE); _defaultState->_depthWriteEnabled = _depthWriteEnabled; } if ((_bits & RS_DEPTH_FUNC) && (_depthFunction != _defaultState->_depthFunction)) { glDepthFunc((GLenum)_depthFunction); _defaultState->_depthFunction = _depthFunction; } // if ((_bits & RS_STENCIL_TEST) && (_stencilTestEnabled != _defaultState->_stencilTestEnabled)) // { // if (_stencilTestEnabled) // glEnable(GL_STENCIL_TEST); // else // glDisable(GL_STENCIL_TEST); // _defaultState->_stencilTestEnabled = _stencilTestEnabled; // } // if ((_bits & RS_STENCIL_WRITE) && (_stencilWrite != _defaultState->_stencilWrite)) // { // glStencilMask(_stencilWrite); // _defaultState->_stencilWrite = _stencilWrite; // } // if ((_bits & RS_STENCIL_FUNC) && (_stencilFunction != _defaultState->_stencilFunction || // _stencilFunctionRef != _defaultState->_stencilFunctionRef || // _stencilFunctionMask != _defaultState->_stencilFunctionMask)) // { // glStencilFunc((GLenum)_stencilFunction, _stencilFunctionRef, _stencilFunctionMask); // _defaultState->_stencilFunction = _stencilFunction; // _defaultState->_stencilFunctionRef = _stencilFunctionRef; // _defaultState->_stencilFunctionMask = _stencilFunctionMask; // } // if ((_bits & RS_STENCIL_OP) && (_stencilOpSfail != _defaultState->_stencilOpSfail || // _stencilOpDpfail != _defaultState->_stencilOpDpfail || // _stencilOpDppass != _defaultState->_stencilOpDppass)) // { // glStencilOp((GLenum)_stencilOpSfail, (GLenum)_stencilOpDpfail, (GLenum)_stencilOpDppass); // _defaultState->_stencilOpSfail = _stencilOpSfail; // _defaultState->_stencilOpDpfail = _stencilOpDpfail; // _defaultState->_stencilOpDppass = _stencilOpDppass; // } _defaultState->_bits |= _bits; }
static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob) { unsigned char obcol[4]; bool is_tex, solidtex; Mesh *me = ob->data; ImagePaintSettings *imapaint = &scene->toolsettings->imapaint; /* XXX scene->obedit warning */ /* texture draw is abused for mask selection mode, do this so wire draw * with face selection in weight paint is not lit. */ if ((v3d->drawtype <= OB_WIRE) && (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT))) { solidtex = false; Gtexdraw.is_lit = 0; } else if (v3d->drawtype == OB_SOLID || ((ob->mode & OB_MODE_EDIT) && v3d->drawtype != OB_TEXTURE)) { /* draw with default lights in solid draw mode and edit mode */ solidtex = true; Gtexdraw.is_lit = -1; } else { /* draw with lights in the scene otherwise */ solidtex = false; if (v3d->flag2 & V3D_SHADELESS_TEX) Gtexdraw.is_lit = 0; else Gtexdraw.is_lit = GPU_scene_object_lights(scene, ob, v3d->lay, rv3d->viewmat, !rv3d->is_persp); } rgba_float_to_uchar(obcol, ob->col); if (solidtex || v3d->drawtype == OB_TEXTURE) is_tex = true; else is_tex = false; Gtexdraw.ob = ob; Gtexdraw.stencil = (imapaint->flag & IMAGEPAINT_PROJECT_LAYER_STENCIL) ? imapaint->stencil : NULL; Gtexdraw.is_texpaint = (ob->mode == OB_MODE_TEXTURE_PAINT); Gtexdraw.texpaint_material = (imapaint->mode == IMAGEPAINT_MODE_MATERIAL); Gtexdraw.canvas = (Gtexdraw.texpaint_material) ? NULL : imapaint->canvas; Gtexdraw.is_tex = is_tex; /* naughty multitexturing hacks to quickly support stencil + shading + alpha blending * in new texpaint code. The better solution here would be to support GLSL */ if (Gtexdraw.is_texpaint) { glActiveTexture(GL_TEXTURE1); glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR); glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); /* load the stencil texture here */ if (Gtexdraw.stencil != NULL) { glActiveTexture(GL_TEXTURE2); if (GPU_verify_image(Gtexdraw.stencil, NULL, false, false, false, false)) { float col[4] = {imapaint->stencil_col[0], imapaint->stencil_col[1], imapaint->stencil_col[2], 1.0f}; glEnable(GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_CONSTANT); glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE); glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, col); if ((imapaint->flag & IMAGEPAINT_PROJECT_LAYER_STENCIL_INV) == 0) { glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_ONE_MINUS_SRC_COLOR); } else { glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR); } } } glActiveTexture(GL_TEXTURE0); } Gtexdraw.color_profile = BKE_scene_check_color_management_enabled(scene); Gtexdraw.use_game_mat = (RE_engines_find(scene->r.engine)->flag & RE_GAME) != 0; Gtexdraw.use_backface_culling = (v3d->flag2 & V3D_BACKFACE_CULLING) != 0; memcpy(Gtexdraw.obcol, obcol, sizeof(obcol)); set_draw_settings_cached(1, NULL, NULL, Gtexdraw); glShadeModel(GL_SMOOTH); glCullFace(GL_BACK); glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, (me->flag & ME_TWOSIDED) ? GL_TRUE : GL_FALSE); }
ENTRYPOINT void draw_providence(ModeInfo * mi) { providencestruct *mp; Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); if(!providence) return; mp = &providence[MI_SCREEN(mi)]; MI_IS_DRAWN(mi) = True; if(!mp->glx_context) return; glXMakeCurrent(display, window, *(mp->glx_context)); /* setup twoside lighting */ glLightfv(GL_LIGHT0, GL_AMBIENT, ambient2); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, mp->position0); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_NORMALIZE); glFrontFace(GL_CCW); /* glDisable(GL_CULL_FACE); */ glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); 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); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glRotatef(current_device_rotation(), 0, 0, 1); /* modify camera */ if(fabs(mp->camera_velocity) > EPSILON) { mp->camera_z = max(min(mp->camera_z + 0.1*mp->camera_velocity, -4.0), -12.0); mp->camera_velocity = 0.95*mp->camera_velocity; } /* rotate providence */ glTranslatef(0.0, 0.0, mp->camera_z + sin(mp->theta/4.0)); glRotatef(10.0+20.0*sin(mp->theta/2.0), 1.0, 0.0, 0.0); gltrackball_rotate(mp->trackball); glRotatef(mp->theta * 180.0 / Pi, 0.0, -1.0, 0.0); # ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */ { GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi); int o = (int) current_device_rotation(); if (o != 0 && o != 180 && o != -180) glScalef (1/h, 1/h, 1/h); } # endif /* draw providence */ draw_providence_strip(mi); glPopMatrix(); if(MI_IS_FPS(mi)) do_fps (mi); glFlush(); glXSwapBuffers(display, window); /* update */ mp->currenttime += 1.0 / FPS; mp->theta = mp->currenttime / 2.0 * mp->theta_scale; update_particles(mp); }
M(void, glCullFace, jint mode) { glCullFace(mode); }
int __cdecl main(int argc, char* argv[]) { WNDCLASSEX wc={sizeof(WNDCLASSEX), 0, wp, 0, 0, 0, 0, 0, 0, 0, "GLAP301"}; wc.hCursor=LoadCursor(0, IDC_ARROW);; wc.hIcon=LoadIcon(0,IDI_APPLICATION); RegisterClassEx(&wc); RECT wrect={0, 0, W, H}; AdjustWindowRectEx(&wrect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_APPWINDOW); HWND win=CreateWindowEx(WS_EX_APPWINDOW, "GLAP301", "Render Window", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, wrect.right-wrect.left, wrect.bottom-wrect.top, 0, 0, 0, 0); ShowWindow(win, SW_SHOWNORMAL); UpdateWindow(win); MSG msg={0, 0, 0, 0, 0, {0, 0}}; CTimer timer; CUIGL GL; GL.Init(W, H, 1, 1, win); WGLPROC(glCreateShader); WGLPROC(glShaderSource); WGLPROC(glCompileShader); WGLPROC(glGetShaderiv); WGLPROC(glGetShaderInfoLog); WGLPROC(glCreateProgram); WGLPROC(glAttachShader); WGLPROC(glLinkProgram); WGLPROC(glUseProgram); WGLPROC(glGenBuffers); WGLPROC(glDeleteBuffers); WGLPROC(glBindBuffer); WGLPROC(glBufferData); WGLPROC(glMapBuffer); WGLPROC(glUnmapBuffer); WGLPROC(glVertexAttribPointer); WGLPROC(glGetAttribLocation); WGLPROC(glEnableVertexAttribArray); WGLPROC(glActiveTexture); WGLPROC(glGetUniformLocation); WGLPROC(glProgramUniform1i); WGLPROC(glProgramUniform3f); WGLPROC(glProgramUniform4f); WGLPROC(glProgramUniformMatrix4fv); GLuint ibo=-1; glGenBuffers(1, &ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibsize, ib, GL_STATIC_DRAW); GLuint vbo=-1; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, vbsize, vb, GL_STATIC_DRAW); glEnableClientState(GL_VERTEX_ARRAY); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glEnableVertexAttribArray(4); glEnable(GL_DEPTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); GLuint body_tex=LoadTexture("data\\body_diff.png"); GLuint body_norm=LoadTexture("data\\body_norm.png"); GLuint fur_tex=LoadTexture("data\\fur_diff.png"); GLuint fur_norm=LoadTexture("data\\fur_norm.png"); GLShader sh; glClearColor(0.3f, 0.5f, 0.8f, 1.0f); glClearDepth(1.0f); while(1) { while(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); if(msg.message==WM_QUIT) break; } if(gAppState.reloadShaders) { sh.CreateFromFile("data\\model.vs", "data\\model.fs"); gAppState.reloadShaders=false; glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_pos"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(0*4)); glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_nor"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(3*4)); glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_tan"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(10*4)); glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_bin"), 3, GL_FLOAT, GL_FALSE, 4*16, (void*)(13*4)); glVertexAttribPointer(glGetAttribLocation(sh.GetPName(), "i_tex"), 2, GL_FLOAT, GL_FALSE, 4*16, (void*)(6*4)); } glProgramUniform1i(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"sTex"), 0); glProgramUniform1i(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"sNor"), 1); float4x4 wm; wm=float4x4::Scale(0.05) *float4x4::RotY(-sin(mpx), cos(mpx)) *float4x4::RotX(-1, 0) *float4x4::RotX(-sin(mpy*0.3), cos(mpy*0.3)) ; float fov=1.3; float camrx=(mx-W/2.0f)/5000.0; float camry=(my-H/2.0f)/5000.0; float4x4 vpm=float4x4::Projection(0.25, 2000, fov, H/(float)W*fov).Transposed() *float4x4::Translation(0, 0, dz) *float4x4::RotY(0, -1) *float4x4::RotX(sin(camry), cos(camry)) *float4x4::RotY(-sin(camrx), cos(camrx)) ; glProgramUniformMatrix4fv(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"u_wm" ), 1, false, &wm.m00); glProgramUniformMatrix4fv(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"u_vpm"), 1, false, &vpm.m00); double time=timer.GetTime(); float lightPos0[3]={sin(time),0.5, cos(time)}; float lightPos1[3]={sin(-time*0.5),-0.5, cos(time*0.5)};; float lightPos2[3]={camrx*70, camry*70, -3}; float lightCol0[3]={1.0,0.7,0.3}; float lightCol1[3]={0.3,0.7,1.0}; float lightCol2[3]={1.0,1.0,1.0}; glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos0"), lightPos0[0], lightPos0[1], lightPos0[2]); glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos1"), lightPos1[0], lightPos1[1], lightPos1[2]); glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightPos2"), lightPos2[0], lightPos2[1], lightPos2[2]); glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol0"), lightCol0[0], lightCol0[1], lightCol0[2]); glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol1"), lightCol1[0], lightCol1[1], lightCol1[2]); glProgramUniform3f(sh.GetPName(), glGetUniformLocation(sh.GetPName(),"lightCol2"), lightCol2[0], lightCol2[1], lightCol2[2]); glDepthMask(true); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); sh.Use(); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, body_tex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, body_norm); glDisable(GL_BLEND); glEnable(GL_CULL_FACE); glDrawElements(GL_TRIANGLES, (4340*3), GL_UNSIGNED_INT, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, fur_tex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, fur_norm); glDepthMask(false); glEnable(GL_BLEND); glDisable(GL_CULL_FACE); glDrawElements(GL_TRIANGLES, indexcount-(4340*3), GL_UNSIGNED_INT, (void*)(4340*3*4)); GL.FrameEnd(); if(msg.message==WM_QUIT) break; if(gAppState.quitRequested) break; Sleep(10); // prevent 100% CPU consuming } return 0; };
int main( int argc, char** argv ) { std::cout << "Starting..\n"; std::vector<std::string> file_names; parse_args(argc, argv, file_names); file_names.push_back(std::string("b0e0.hgt")); InitGraphics(); glfwSetWindowTitle( "p7" ); // Ensure we can capture the escape key being pressed below glfwEnable( GLFW_STICKY_KEYS ); // Dark blue background glClearColor(0.7f, 0.7f, 0.7f, 0.0f); // Enable depth test glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); // Accept fragment if it closer to the camera than the former one glDepthFunc(GL_LESS); // glFrontFace(GL_CCW); // Create and compile our GLSL program from the shaders GLuint programIDs[2] = { LoadShaders( "tvs.vertexshader", "cfs.fragmentshader" ), LoadShaders( "tvs2.vertexshader", "cfs.fragmentshader" )}; std::cout << "Linked shaders..\n"; // Get a handle for our "MVP" uniform GLuint MatrixIDs[2] = {glGetUniformLocation(programIDs[0], "MVP"), glGetUniformLocation(programIDs[1], "MVP")}; GLuint EdgexIDs[2] = {glGetUniformLocation(programIDs[0], "Edgex"), glGetUniformLocation(programIDs[1], "Edgex")}; GLuint EdgeyIDs[2] = {glGetUniformLocation(programIDs[0], "Edgey"), glGetUniformLocation(programIDs[1], "Edgey")}; GLuint HeightIDs[2] = {glGetUniformLocation(programIDs[0], "height"), glGetUniformLocation(programIDs[1], "height")}; GLuint TextureIDs[2] = {glGetUniformLocation(programIDs[0], "tex2d"), glGetUniformLocation(programIDs[1], "tex2d")}; GLuint TimeIDs[2] = {glGetUniformLocation(programIDs[0], "time"), glGetUniformLocation(programIDs[1], "time")}; GLuint AlphaIDs[2] = {glGetUniformLocation(programIDs[0], "alpha"), glGetUniformLocation(programIDs[1], "alpha")}; std::cout << "Got uniforms..\n"; std::cout << glGetString(GL_VERSION) << std::endl; std::cout << "Loadin textures...\n"; char texName[] = "texture3.jpg"; std::cout << texName << std::endl; int t1x,t1y,t1comp; FILE* t1f = fopen(texName, "rb"); unsigned char* tex1data = stbi_load_from_file(t1f, &t1x, &t1y, &t1comp,0); unsigned int tex_2d; glGenTextures(1, &tex_2d); glBindTexture(GL_TEXTURE_2D, tex_2d); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t1x, t1y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex1data); /* char texNameCl[] = "textureClouds3.png"; std::cout << texNameCl << std::endl; int t2x,t2y,t2comp; FILE* t2f = fopen(texNameCl, "rb"); unsigned char* tex2data = stbi_load_from_file (t2f, &t2x, &t2y, &t2comp,0); unsigned int tex_cl; glGenTextures(1, &tex_cl); glBindTexture(GL_TEXTURE_2D, tex_cl); //--> glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t2x, t2y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex2data); */ std::cout << "Done!\n"; const int side(1201); const int vBOsize(file_names.size()); //Vertices: short piece_map[360][181]; for(int i=0; i<360; i++) for(int y=0; y<=180; y++) piece_map[i][y] = -1; unsigned int numberOfVertices=side*side; GLuint vaoObjects[vBOsize+1], vertexBufferObject, vBOs[vBOsize+1]; std::vector<std::pair<int, int> > edges(vBOsize+1); // --> std::cout << "Generating arrays...\n"; glGenVertexArrays(vBOsize, vaoObjects); std::cout << "Done\n"; glGenBuffers(vBOsize, vBOs); int height; // <--- for(short i=0; i< vBOsize; i++) { std::vector< int > vertexPositionsVec(3*numberOfVertices); int* vertexPositions = &vertexPositionsVec[0]; loadVertices(file_names[i], vertexPositionsVec, true, side, edges[i], height); glBindVertexArray(vaoObjects[i]); glBindBuffer(GL_ARRAY_BUFFER, vBOs[i]); glVertexAttribPointer( 0, // attribute. No particular reason for 0, but must match the layout in the shader. 3, // size GL_INT, // type GL_FALSE, // normalized? 0, // stride (void*)0 // array buffer offset ); glBufferData(GL_ARRAY_BUFFER, sizeof(int)*3*numberOfVertices, vertexPositions, GL_STATIC_DRAW); if(i<vBOsize-1) { piece_map[edges[i].second+180][edges[i].first+90]=i; std::cout << edges[i].second+180 << " " << edges[i].first+90 << std::endl; } } //Indices:: GLuint indexBufferObject, iBOs[maxLoD], numberOfIndices; std::vector<GLuint> nOIs(maxLoD); glGenBuffers(maxLoD, iBOs); for(unsigned int density=1, i=0; i<maxLoD; i++, density*=2) { std::cout << "Entering for with i: " << i << "\n"; nOIs[i]=(side-1)/density; if((side-1)%density!=0) nOIs[i]+=1; nOIs[i]=6*(nOIs[i]*(nOIs[i])); std::cout << "Allocating memory...\n"; GLuint* indices = new GLuint [nOIs[i]]; std::cout << "Done.\n"; glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBOs[i]); std::cout << "Density: " << density << " Number of indices: " << nOIs[i] << std::endl; genIndices(indices, side, density); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*nOIs[i], indices, GL_STATIC_DRAW); std::cout << "Leaving for with i: " << i << "\n"; } // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units glm::mat4 Projection = // glm::mat4(1.0f); glm::perspective(45.0f, 4.0f / 3.0f, 100.f, 30000.0f); // Camera matrix // int xVw = edges[0].first*side, yVw = edges[0].second*side; int xVw = 6000, yVw = -6000; height = 3000; glm::mat4 View = glm::lookAt( glm::vec3(xVw,yVw,2*height), // Camera is at (4,3,-3), in World Space glm::vec3(xVw,yVw,0), // and looks at the origin glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down) ); // Model matrix : an identity matrix (model will be at the origin) glm::mat4 Model = glm::mat4(1.0f); // Our ModelViewProjection : multiplication of our 3 matrices glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around std::cout << "Init done.\n"; glfwSetKeyCallback(Key_Callback); double last_time = glfwGetTime(), last_reset=last_time; int FPScounter=0; x = edges[0].second*12010; startx=x; y = edges[0].first*12010; starty=y; std::cout << edges[0].first << " " << edges[0].second << std::endl; do { int ex = x/12010+180; int ey = y/12010+90; //time statistics: FPScounter++; double cur_time = glfwGetTime(); if(cur_time-last_reset>=2) { double FPS = (float)FPScounter/(cur_time-last_reset); std::cout << "FPS: " << FPS << " lod: " << iBOindex << std::endl; std::cout << ex << " " << ey << " " << alpha << std::endl; if(autolod && abs(FPS-optfps)>4) { if(FPS<optfps && iBOindex<maxLoD) iBOindex++; if(FPS>4*optfps && iBOindex > 0) iBOindex--; } FPScounter=0; last_reset=cur_time; } last_time=cur_time; // Clear the screen glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use our shader glUseProgram(programIDs[ball]); glm::mat4 Vw; // Send our transformation to the currently bound shader, // in the "MVP" uniform Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball)) * glm::rotate(mat4(1.0), oz, glm::vec3(0,1,0)) * glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0)) * glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1)) * glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball))); glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]); glUniform1i(HeightIDs[ball], 0); glUniform1f(TimeIDs[ball], glfwGetTime()); glUniform1f(AlphaIDs[ball], (float)alpha*0.1); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, tex_2d); glUniform1i(TextureIDs[ball], /*GL_TEXTURE0+*/0); indexBufferObject=iBOs[iBOindex]; numberOfIndices=nOIs[iBOindex]; // std::cout << ex << " " << ey << std::endl; if(ball==0) { glCullFace(GL_FRONT); for(int i = max(ex-3,0); i<= min(ex+3,360) ; i++) for(int j=max(ey-3,0); j<= min(ey+3,180); j++) { glUniform1i(EdgexIDs[ball], (i-180)); glUniform1i(EdgeyIDs[ball], (j-90)); int point; if(piece_map[i][j]==-1) { point=vBOsize-1; draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]); } else { point = piece_map[i][j]; draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices); } // std::cout << "Drawing " << file_names[point] << "with mods " << i-180 << " " << j-90 << std::endl // << i << " " << ex << " " << j << " " << ey << std::endl; } } else { glCullFace(GL_FRONT); for(int i=/*edges[0].second+180+*/0; i</*edges[0].second+18*/360; i++) for(int j=/*edges[0].first+90+*/0; j<=/*edges[0].first+90*/180; j++) { glUniform1i(EdgexIDs[ball], (i-180)); glUniform1i(EdgeyIDs[ball], (j-90)); int point; if(piece_map[i][j]==-1) { point=vBOsize-1; draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]); } else { point = piece_map[i][j]; draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices); } } } //CLOUDS /* Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball)) * glm::rotate(mat4(1.0), oz+(float)glfwGetTime(), glm::vec3(0,1,0)) * glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0)) * glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1)) * glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball))); glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]); glUniform1i(HeightIDs[ball], 100); glUniform1f(TimeIDs[ball], glfwGetTime()); glUniform1f(AlphaIDs[ball], 0.25); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, tex_cl); glUniform1i(TextureIDs[ball], 0); indexBufferObject=iBOs[iBOindex]; numberOfIndices=nOIs[iBOindex]; // std::cout << ex << " " << ey << std::endl; if(ball==0) { glCullFace(GL_FRONT); for(int i = max(ex-3,0); i<= min(ex+3,360) ;i++) for(int j=max(ey-3,0); j<= min(ey+3,180); j++) { glUniform1i(EdgexIDs[ball], (i-180)); glUniform1i(EdgeyIDs[ball], (j-90)); int point; { point=vBOsize-1; draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]); } } } else { glCullFace(GL_FRONT); for(int i=0; i<360;i++) for(int j=0; j<=180;j++) { glUniform1i(EdgexIDs[ball], (i-180)); glUniform1i(EdgeyIDs[ball], (j-90)); int point; { point=vBOsize-1; draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]); } } }*/ // Swap buffers glfwSwapBuffers(); } // Check if the ESC key was pressed or the window was closed while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS && glfwGetWindowParam( GLFW_OPENED ) ); // Cleanup VBO and shader glDeleteProgram(programIDs[0]); glDeleteProgram(programIDs[1]); // CleanVBOs(vaoObjects, vBOs, vBOsize+1, iBOs, tex_2d); std::cout << "Cleaning done, terminating..\n"; // Close OpenGL window and terminate GLFW glfwTerminate(); return 0; }
void GlRasterStateInterface::BindRasterState( SRasterState const &refNewState, bool bForce ) { bForce = true; SRasterState rNewState = refNewState; SRasterState overridden; GetOverrideMergedRasterState(rNewState, overridden); SRasterState &rLast = mLastState; bool bAlphaTestChanged = ( overridden.GetAlphaTest() != rLast.GetAlphaTest() ); // bool bTextureModeChanged = ( overridden.GetTextureMode() != rLast.GetTextureMode() ); // bool bTextureActiveChanged = ( overridden.GetTextureActive()!= rLast.GetTextureActive() ); bool bBlendingChanged = ( overridden.GetBlending() != rLast.GetBlending() ); bool bDepthTestChanged = ( overridden.GetDepthTest() != rLast.GetDepthTest() ); //bool bStencilModeChanged = ( overridden.GetStencilID() != rLast.GetStencilID() ); bool bShadeModelChanged = ( overridden.GetShadeModel() != rLast.GetShadeModel() ); bool bCullTestChanged = ( overridden.GetCullTest() != rLast.GetCullTest() ); bool bScissorTestChanged = ( overridden.GetScissorTest() != rLast.GetScissorTest() ); GL_ERRORCHECK(); if( true ) { glDisable( GL_CULL_FACE ); } else if( bCullTestChanged || bForce ) { switch( overridden.GetCullTest() ) { case ECULLTEST_OFF: glDisable( GL_CULL_FACE ); break; case ECULLTEST_PASS_FRONT: glCullFace( GL_BACK ); glFrontFace( GL_CCW ); glEnable( GL_CULL_FACE ); break; case ECULLTEST_PASS_BACK: glCullFace( GL_FRONT ); glFrontFace( GL_CCW ); glEnable( GL_CULL_FACE ); break; } } ////////////////////////////// /*#if( _BUILD_LEVEL > 1 ) if( IsPickState() ) { bBlendingChanged = true; bDepthTestChanged = true; bShadeModelChanged = true; //bTextureModeChanged = true; bAlphaTestChanged = true; overridden.SetBlending( EBLENDING_OFF ); overridden.SetAlphaTest( EALPHATEST_OFF, 0 ); overridden.SetDepthTest( EDEPTHTEST_LEQUALS ); overridden.SetShadeModel( ESHADEMODEL_FLAT ); //overridden.SetTextureMode( ETEXMODE_OFF ); } #endif*/ ////////////////////////////// GL_ERRORCHECK(); ///////////////////////////////////////////////// glDepthMask( overridden.GetZWriteMask() ); glColorMask( overridden.GetRGBWriteMask(), overridden.GetRGBWriteMask(), overridden.GetRGBWriteMask(), overridden.GetAWriteMask() ); // glDepthMask( GL_TRUE ); // glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE ); ///////////////////////////////////////////////// if( true ) { glDisable( GL_STENCIL_TEST ); } ///////////////////////////////////////////////// // Win32 GL Alpha if( false ) { //glDisable( GL_ALPHA_TEST ); } else if( bAlphaTestChanged || bForce ) { static const F32 frecip = 1.0f / 15.0f; F32 fAlphaRef = frecip * (F32) overridden.muAlphaRef; switch( overridden.muAlphaTest ) { case EALPHATEST_OFF: //glDisable( GL_ALPHA_TEST ); GL_ERRORCHECK(); break; case EALPHATEST_GREATER: //glEnable( GL_ALPHA_TEST ); //glAlphaFunc( GL_GREATER, fAlphaRef ); GL_ERRORCHECK(); break; case EALPHATEST_LESS: //glEnable( GL_ALPHA_TEST ); //glAlphaFunc( GL_LESS, fAlphaRef ); GL_ERRORCHECK(); break; } } ///////////////////////////////////////////////// // Win32 GL Depth if( false ) { glDisable( GL_DEPTH_TEST ); } else if( bDepthTestChanged || bForce ) { GL_ERRORCHECK(); switch( overridden.GetDepthTest() ) { case EDEPTHTEST_OFF: glDisable( GL_DEPTH_TEST ); break; case EDEPTHTEST_LESS: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_LESS ); break; case EDEPTHTEST_LEQUALS: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_LEQUAL ); break; case EDEPTHTEST_GREATER: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_GREATER ); break; case EDEPTHTEST_GEQUALS: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_GEQUAL ); break; case EDEPTHTEST_EQUALS: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_EQUAL ); break; case EDEPTHTEST_ALWAYS: glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_ALWAYS ); break; default: OrkAssert( false ); break; } GL_ERRORCHECK(); } ///////////////////////////////////////////////// if( false ) { glDisable( GL_SCISSOR_TEST ); } else if( bScissorTestChanged || bForce ) { GL_ERRORCHECK(); switch( overridden.GetScissorTest() ) { case ESCISSORTEST_OFF: // glDisable( GL_SCISSOR_TEST ); break; case ESCISSORTEST_ON: // glEnable( GL_SCISSOR_TEST ); break; } GL_ERRORCHECK(); } ///////////////////////////////////////////////// if( false ) { glDisable( GL_BLEND ); } else if( bBlendingChanged || bForce ) { //glDisable( GL_BLEND ); //glEnable( GL_BLEND ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); switch( overridden.GetBlending() ) { case EBLENDING_OFF: glDisable( GL_BLEND ); break; case EBLENDING_DSTALPHA: glEnable( GL_BLEND ); glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA ); break; case EBLENDING_ALPHA: glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA ); break; case EBLENDING_ADDITIVE: glEnable( GL_BLEND ); glBlendFunc( GL_ONE, GL_ONE ); break; case EBLENDING_SUBTRACTIVE: glEnable( GL_BLEND ); glBlendFunc( GL_ZERO, GL_ONE_MINUS_SRC_COLOR ); break; case EBLENDING_ALPHA_ADDITIVE: glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE ); break; case EBLENDING_ALPHA_SUBTRACTIVE: glEnable( GL_BLEND ); glBlendFunc( GL_ZERO, GL_ONE_MINUS_SRC_ALPHA ); break; case EBLENDING_MODULATE: glEnable( GL_BLEND ); glBlendFunc( GL_ZERO, GL_SRC_ALPHA ); break; default : OrkAssert( false ); break; } } GL_ERRORCHECK(); if( false ) { //glShadeModel( GL_FLAT ); } else if( bShadeModelChanged || bForce ) { switch( overridden.GetShadeModel() ) { case ESHADEMODEL_FLAT: //glShadeModel( GL_FLAT ); break; case ESHADEMODEL_SMOOTH: //glShadeModel( GL_SMOOTH ); break; default: break; } } GL_ERRORCHECK(); u32 upolyoffset = overridden.GetPolyOffset(); if( false ) //0 == upolyoffset ) { glDisable( GL_POLYGON_OFFSET_FILL ); } else { glEnable( GL_POLYGON_OFFSET_FILL ); glPolygonOffset( -1.0f, float(upolyoffset) ); } }
void app_update_and_render(App *app) { app->current_scene = (int)(app->elapsed_time / 20.0f) % NUM_SCENES; Scene scene = app->scenes[app->current_scene]; float model_scale = animate_model_scale(app->elapsed_time); float aspect_ratio = app->window_width / (float)app->window_height; mat4 mat_projection = perspective(scene.fov, aspect_ratio, scene.z_near, scene.z_far); mat4 mat_cube_model = rotateX(PI / 2.0f) * scale(model_scale); mat4 mat_view = animate_camera(app->elapsed_time); glEnable(GL_CULL_FACE); glFrontFace(GL_CCW); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthRangef(0.0, 1.0); glClearDepthf(1.0f); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); //////////////// // Draw backdrop glDepthMask(GL_FALSE); glUseProgram(app->program_backdrop); glBindBuffer(GL_ARRAY_BUFFER, app->vbo_quad); attribfv(backdrop, position, 2, 0); uniform3fv(backdrop, sun_dir, scene.sun_dir); uniform2f(backdrop, screen_size, app->window_width, app->window_height); uniform1f(backdrop, inv_tan_fov, 1.0f / (scene.fov / 2.0f)); uniformm4(backdrop, view, mat_view); glDrawArrays(GL_TRIANGLES, 0, 6); glDepthMask(GL_TRUE); ////////////////////////// // Draw tessellated sphere glUseProgram(app->program_mapping); glBindBuffer(GL_ARRAY_BUFFER, app->vbo_cube); attribfv(mapping, position, 3, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_CUBE_MAP, scene.heightmap); uniform1i(mapping, heightmap, 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_CUBE_MAP, scene.diffusemap); uniform1i(mapping, diffusemap, 1); uniform1f(mapping, height_scale, scene.height_scale); uniform1f(mapping, use_mip, scene.use_mip ? 1.0f : 0.0f); uniform1f(mapping, max_lod_coverage, scene.max_lod_coverage); uniform2f(mapping, screen_size, app->window_width, app->window_height); uniformm4(mapping, model, mat_cube_model); uniformm4(mapping, view, mat_view); uniformm4(mapping, projection, mat_projection); glPatchParameteri(GL_PATCH_VERTICES, VERTICES_PER_PATCH); glDrawArrays(GL_PATCHES, 0, NUM_PATCHES * VERTICES_PER_PATCH); }
void drawCam(Player *p, PlayerVisual* pV) { int i; float up[3] = { 0, 0, 1 }; Visual *d = & pV->display; float reflectivity = getReflectivity(); // compute shadow color based on glocal constant & reflectivity for(i = 0; i < 4; i++) gCurrentShadowColor[i] = gShadowColor[i] * (1 - reflectivity); glColor3f(0.0, 1.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); doPerspective(gSettingsCache.fov, (float) d->vp_w / (float) d->vp_h, gSettingsCache.znear, box2_Diameter(& game2->level->boundingBox) * 6.5f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); doLookAt(p->camera->cam, p->camera->target, up); glDisable(GL_LIGHTING); // initial config at frame start glDisable(GL_BLEND); // initial config at frame start // disable writes to alpha glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); /* skybox */ glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); /* skybox done */ /* floor */ if(reflectivity == 0) { // draw floor to fb and stencil (set to 1), // using alpha-blending // TODO: draw floor alpha to fb video_Shader_Setup(& gWorld->floor_shader); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, 255); glEnable(GL_STENCIL_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); nebu_Mesh_DrawGeometry( gWorld->floor ); glDisable(GL_BLEND); glDisable(GL_STENCIL_TEST); video_Shader_Cleanup(& gWorld->floor_shader); } else { /* reflections */ /* first draw reflector to stencil */ /* and reflector alpha to fb */ video_Shader_Setup(& gWorld->floor_shader); // store only reflector alpha in framebuffer glDepthMask(GL_FALSE); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); glStencilFunc(GL_ALWAYS, 1, 255); glEnable(GL_STENCIL_TEST); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); // glEnable(GL_ALPHA_TEST); // glAlphaFunc(GL_GREATER, 0.1f); nebu_Mesh_DrawGeometry( gWorld->floor ); // glDisable(GL_ALPHA_TEST); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 1, 255); video_Shader_Cleanup(& gWorld->floor_shader); /* then draw world & skybox reflected, where stencil is set */ /* protect the alpha buffer */ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); isRenderingReflection = 1; // hack: reverse lighting glPushMatrix(); glScalef(1,1,-1); glCullFace(GL_FRONT); // reverse culling // clip skybox & world to floor plane glEnable(GL_CLIP_PLANE0); { double plane[] = { 0, 0, 1, 0 }; glClipPlane(GL_CLIP_PLANE0, plane); } drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); drawWorld(p, pV); glDisable(GL_CLIP_PLANE0); glCullFace(GL_BACK); glPopMatrix(); isRenderingReflection = 0; // hack: normal lighting /* then blend the skybox into the scene, where stencil is set */ /* modulate with the destination alpha */ glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA); drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f ); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); /* then blend reflector into the scene */ glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1, 1, 1, 1 - reflectivity); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_ALWAYS, 1, 255); video_Shader_Setup(& gWorld->floor_shader); nebu_Mesh_DrawGeometry( gWorld->floor ); video_Shader_Cleanup(& gWorld->floor_shader); glDisable(GL_STENCIL_TEST); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); } /* floor done */ /* planar shadows */ glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); if(reflectivity != 1) // there are no shadows on perfect mirrors drawPlanarShadows(p); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); /* planar shadows done */ drawWorld(p, pV); /* transparent stuff */ /* draw the glow around the other players: */ if (gSettingsCache.show_glow == 1) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); for (i = 0; i < game->players; i++) { if (p != game->player + i && PLAYER_IS_ACTIVE(game->player + i)) { drawGlow(p->camera, game->player + i, gPlayerVisuals + i, d, TRAIL_HEIGHT * 4); } } glDisable(GL_BLEND); } }
/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLES2LightMap::InitView() { CPVRTString ErrorStr; /* Initialize VBO data */ m_Models[0].LoadVbos(); m_Models[1].LoadVbos(); /* Load textures */ if (!LoadTextures(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Clamp the shadow texture to edge (not repeat). glBindTexture(GL_TEXTURE_2D, m_uiShadowTex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); /* Load and compile the shaders & link programs */ if (!LoadShaders(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Set the sampler2D uniforms to corresponding texture units glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sBasetex"), 0); glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sReflect"), 1); glUniform1i(glGetUniformLocation(m_ShaderProgram.uiId, "sShadow"), 2); // Is the scene rotated? bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); /* Initialize Print3D */ if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n"); return false; } /* Calculate the projection and view matrices */ m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate); m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 150), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0)); // Defines the shadow matrix and stores it, shadow matrix for shadow texture mapping PVRTVec3 vLightFrom = PVRTVec3( 85, -85, 100); PVRTVec3 vLightTo = PVRTVec3(0, 0, -25); PVRTVec3 vLightUp = PVRTVec3(0, 1, 0); m_mShadowViewProj = PVRTMat4::LookAtRH(vLightFrom, vLightTo, vLightUp); // Project the shadow from a point (near and far clipping plane are not important here) PVRTMat4 mShadowProj; mShadowProj = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, 1, 1, 2, PVRTMat4::OGL); m_mShadowViewProj = mShadowProj * m_mShadowViewProj; glUniformMatrix4fv(m_ShaderProgram.auiLoc[eShadowProj], 1, GL_FALSE, m_mShadowViewProj.ptr()); /* Set OpenGL ES render states needed for this training course */ // Enable backface culling and depth test glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // Use a nice bright blue as clear colour glClearColor(0.6f, 0.8f, 1.0f, 1.0f); return true; }
void SCSChannelManagerAlphaOnly::merge() { bool isFixedFunction = true; setupProjectiveTexture(isFixedFunction); glEnable(GL_ALPHA_TEST); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glDepthMask(GL_TRUE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); std::vector<Channel> channels = occupied(); for (std::vector<Channel>::const_iterator c = channels.begin(); c!=channels.end(); ++c) { setupTexEnv(*c); scissor->recall(*c); scissor->enableScissor(); const std::vector<Primitive*> primitives = getPrimitives(*c); for (std::vector<Primitive*>::const_iterator j = primitives.begin(); j != primitives.end(); ++j) { glCullFace((*j)->getOperation() == Intersection ? GL_BACK : GL_FRONT); RenderData* primitiveData = getRenderData(*j); GLubyte id = primitiveData->bufferId.a; // Here is an interesting bug, which happened on an ATI HD4670, but actually // might happen on every hardware. I am not sure whether it can be solved // correctly. // Problem is that in optimized mode with some compilers (VC6, Visual Studio 2003 // in particular), when setting the alpha func as follows: // glAlphaFunc(GL_EQUAL, static_cast<float>(id) / 255.0f); // the division is optimized as multiplication with 1.0f/255.0f. // This is a fine and valid optimization. Unfortunately, the results // are not exactly the same as the direct division for some ids. // Which is apparently what the ATI driver is doing internally. // So with comparison with GL_EQUAL fails. // Fortunately the OpenGL standard enforces that the mapping of color byte // values to float fragment values be done by division. So if the // solution found below (just working at double precision) proves // to work once, it should work forever, such that a precompiling // lookup table containing the correct alpha reference values is // not required. However a bad feeling remains. // The SCSChannelManagerFragmentProgram path implemented below should fix this. double alpha = static_cast<double>(id) / 255.0; GLfloat fAlpha = static_cast<float>(alpha); glAlphaFunc(GL_EQUAL, fAlpha); (*j)->render(); } } scissor->disableScissor(); glDisable(GL_ALPHA_TEST); glDisable(GL_CULL_FACE); glDepthFunc(GL_LEQUAL); resetProjectiveTexture(isFixedFunction); clear(); }
void display(){ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glViewport(0, 0, glwidth, glheight); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(1.5, (double)glwidth / (double)glheight, 1.0, 1000.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(150.0,100.0,-200.0, 0.0,0.0,0.0, 0.0,1.0,0.0); glMultMatrixd(Rotate); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, gold_diff); glPushMatrix(); glTranslated(sin(t),cos(t),-3.); glRotatef(90, 1.0f, 0.0f, 0.0f); glutSolidSphere(.3,20,20); glPopMatrix(); glutSolidSphere(1.5,20,20); glLightfv(GL_LIGHT0, GL_POSITION, light0_pos); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red_light); if(!colormask_on){ glColorMask(0,0,0,0); glDepthMask(0); } glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_STENCIL_TEST); glStencilMask(~0); if(frontcull){ glCullFace(GL_FRONT); glStencilFunc(GL_ALWAYS, 1, ~0); glStencilOp(GL_REPLACE, GL_KEEP, GL_REPLACE); /* glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); */ /* glStencilOp(GL_KEEP, GL_INCR, GL_KEEP); */ glPushMatrix(); glTranslated(sin(t),cos(t),-3); glRotatef(90, 1.0f, 0.0f, 0.0f); /* glRotatef(90, 0.0f, 0.0f, 1.0f); */ cylinder(.3,100,20); glPopMatrix(); } if(backcull){ glCullFace(GL_BACK); glStencilFunc(GL_ALWAYS, 1, ~0); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); /* glStencilOp(GL_KEEP, GL_DECR, GL_KEEP); */ glPushMatrix(); glTranslated(sin(t),cos(t),-3.); glRotatef(90, 1.0f, 0.0f, 0.0f); /* glRotatef(90, 0.0f, 0.0f, 1.0f); */ cylinder(.3,100,20); glPopMatrix(); } glDisable(GL_CULL_FACE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_TRUE); glStencilFunc(GL_EQUAL, 1, ~0); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glDisable(GL_DEPTH_TEST); glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,black_light); glBegin(GL_QUADS); glVertex2i(-10, -10); glVertex2i(-10, 10); glVertex2i(10, 10); glVertex2i(10, -10); glEnd(); glEnable(GL_DEPTH_TEST); /* glEnable(GL_DEPTH_TEST); */ glDisable(GL_STENCIL_TEST); console(); t+=1e-2; glFinish(); glutSwapBuffers(); }
void InitGL( void )//__END_INIT__@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@___BEGIN_INIT__ { //========================================================================== #ifdef WIN32 #include "cpp/setPixelFormat.cpp" #include "headerFiles/glext_Init_B.cpp" //------------------------------------- SetVSyncState(true); #endif //========================================================================================================================================================================== //==================================================================================================================== glGenTextures(1, &shadowMap_2D); glBindTexture(GL_TEXTURE_2D, shadowMap_2D); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); //-------------------------------------------------------------------------------------------------------------------- glGenFramebuffers(1, &fboId_2D); glBindFramebuffer(GL_FRAMEBUFFER, fboId_2D); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, shadowMap_2D, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); //######################################################################################################________SHADERS //######################################################################################################________SHADERS //================================================================ //==================================================================================== #include "_MODEL_FOLDERS_/cube/cube_Init.cpp" //==================================================================================== //=================================================================================================================== glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glAlphaFunc(GL_GREATER, 0.1); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); //===================================================================================================================== }//__END_INIT__@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@___END_INIT__
void PrelightPipeline::DrawLight(const std::shared_ptr<Pass> &pass, const std::shared_ptr<SceneNode> &node) { auto light = node->GetComponent<Light>(); auto camPtr = m_CurrentCamera->GetComponent<Camera>(); auto camPos = m_CurrentCamera->GetWorldPosition(); auto mesh = light->GetMesh(); auto worldMatrix = node->GetWorldMatrix(); Shader::Ptr shader = nullptr; if (light->GetType() == LightType::POINT) { float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length(); if (SphereBounds(node->GetWorldPosition(), light->GetRadius() + camNear).IsInsideFast(camPos)) { glDisable(GL_DEPTH_TEST); glCullFace(GL_FRONT); } else { glEnable(GL_DEPTH_TEST); glCullFace(GL_BACK); } worldMatrix.AppendScale(Vector4(light->GetRadius(), 0.0f)); shader = pass->GetShader(ShaderType::POINT_LIGHT); } else if (light->GetType() == LightType::SPOT) { auto coneCenter = node->GetWorldPosition(); auto coneDir = worldMatrix.Multiply(Vector4(0, 1, 0, 0)).Normalized(); float camNear = (camPtr->GetFrustum().GetWorldSpaceCorners()[0] - camPos).Length(); float theta = light->GetOutterAngle() * 0.5f; float height = light->GetRadius(); float extra = camNear / std::sin(theta); coneCenter = coneCenter - coneDir * extra; height += camNear + extra; if (PointInCone(coneCenter, coneDir, height, theta, camPos)) { glDisable(GL_DEPTH_TEST); glCullFace(GL_FRONT); } else { glEnable(GL_DEPTH_TEST); glCullFace(GL_BACK); } shader = pass->GetShader(ShaderType::SPOT_LIGHT); } else { glEnable(GL_DEPTH_TEST); glCullFace(GL_BACK); shader = pass->GetShader(ShaderType::DIR_LIGHT); } if (shader == nullptr) { LOGW << "Shader for light " << node->GetName() << " not found!"; return; } shader->Bind(); shader->BindCamera(m_CurrentCamera); shader->BindMatrix(Matrix4::WORLD_MATRIX, worldMatrix); shader->BindLight(node); shader->BindMesh(mesh); for (unsigned int i = 0; i < pass->GetTextureCount(true); i++) { auto ptr = pass->GetTextureAt(i, true); shader->BindTexture(ptr->GetName(), ptr); } glDrawElements(GL_TRIANGLES, mesh->Indices.Data.size(), GL_UNSIGNED_INT, 0); shader->UnBind(); m_DrawCall++; }
void StateBlock::restore(long stateOverrideBits) { CC_ASSERT(_defaultState); // If there is no state to restore (i.e. no non-default state), do nothing. // if (_defaultState->_bits == 0) if ( (stateOverrideBits | _defaultState->_bits) == stateOverrideBits) { return; } // Restore any state that is not overridden and is not default if (!(stateOverrideBits & RS_BLEND) && (_defaultState->_bits & RS_BLEND)) { glEnable(GL_BLEND); _defaultState->_bits &= ~RS_BLEND; _defaultState->_blendEnabled = true; } if (!(stateOverrideBits & RS_BLEND_FUNC) && (_defaultState->_bits & RS_BLEND_FUNC)) { GL::blendFunc(GL_ONE, GL_ZERO); _defaultState->_bits &= ~RS_BLEND_FUNC; _defaultState->_blendSrc = BLEND_ONE; _defaultState->_blendDst = BLEND_ZERO; } if (!(stateOverrideBits & RS_CULL_FACE) && (_defaultState->_bits & RS_CULL_FACE)) { glDisable(GL_CULL_FACE); _defaultState->_bits &= ~RS_CULL_FACE; _defaultState->_cullFaceEnabled = false; } if (!(stateOverrideBits & RS_CULL_FACE_SIDE) && (_defaultState->_bits & RS_CULL_FACE_SIDE)) { glCullFace((GLenum)GL_BACK); _defaultState->_bits &= ~RS_CULL_FACE_SIDE; _defaultState->_cullFaceSide = CULL_FACE_SIDE_BACK; } if (!(stateOverrideBits & RS_FRONT_FACE) && (_defaultState->_bits & RS_FRONT_FACE)) { glFrontFace((GLenum)GL_CCW); _defaultState->_bits &= ~RS_FRONT_FACE; _defaultState->_frontFace = FRONT_FACE_CCW; } if (!(stateOverrideBits & RS_DEPTH_TEST) && (_defaultState->_bits & RS_DEPTH_TEST)) { glEnable(GL_DEPTH_TEST); _defaultState->_bits &= ~RS_DEPTH_TEST; _defaultState->_depthTestEnabled = true; } if (!(stateOverrideBits & RS_DEPTH_WRITE) && (_defaultState->_bits & RS_DEPTH_WRITE)) { glDepthMask(GL_FALSE); _defaultState->_bits &= ~RS_DEPTH_WRITE; _defaultState->_depthWriteEnabled = false; } if (!(stateOverrideBits & RS_DEPTH_FUNC) && (_defaultState->_bits & RS_DEPTH_FUNC)) { glDepthFunc((GLenum)GL_LESS); _defaultState->_bits &= ~RS_DEPTH_FUNC; _defaultState->_depthFunction = DEPTH_LESS; } // if (!(stateOverrideBits & RS_STENCIL_TEST) && (_defaultState->_bits & RS_STENCIL_TEST)) // { // glDisable(GL_STENCIL_TEST); // _defaultState->_bits &= ~RS_STENCIL_TEST; // _defaultState->_stencilTestEnabled = false; // } // if (!(stateOverrideBits & RS_STENCIL_WRITE) && (_defaultState->_bits & RS_STENCIL_WRITE)) // { // glStencilMask(RS_ALL_ONES); // _defaultState->_bits &= ~RS_STENCIL_WRITE; // _defaultState->_stencilWrite = RS_ALL_ONES; // } // if (!(stateOverrideBits & RS_STENCIL_FUNC) && (_defaultState->_bits & RS_STENCIL_FUNC)) // { // glStencilFunc((GLenum)RenderState::STENCIL_ALWAYS, 0, RS_ALL_ONES); // _defaultState->_bits &= ~RS_STENCIL_FUNC; // _defaultState->_stencilFunction = RenderState::STENCIL_ALWAYS; // _defaultState->_stencilFunctionRef = 0; // _defaultState->_stencilFunctionMask = RS_ALL_ONES; // } // if (!(stateOverrideBits & RS_STENCIL_OP) && (_defaultState->_bits & RS_STENCIL_OP)) // { // glStencilOp((GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP, (GLenum)RenderState::STENCIL_OP_KEEP); // _defaultState->_bits &= ~RS_STENCIL_OP; // _defaultState->_stencilOpSfail = RenderState::STENCIL_OP_KEEP; // _defaultState->_stencilOpDpfail = RenderState::STENCIL_OP_KEEP; // _defaultState->_stencilOpDppass = RenderState::STENCIL_OP_KEEP; // } }
void PrelightPipeline::Execute(const std::shared_ptr<SceneManager> &sceneManager) { // pre m_DrawCall = 0; m_CurrentCamera = nullptr; m_CurrentShader = nullptr; SortPassByIndex(); // find visible nodes, 1 cam 1 query std::unordered_map<std::string, RenderQuery::Ptr> queries; for (auto pair : m_PassMap) { auto pass = pair.second; auto camNode = pass->GetCameraNode(); if (camNode == nullptr) { LOGW << "Camera for pass " + pass->GetName() + " not found!"; continue; } auto it = queries.find(camNode->GetName()); if (it != queries.end()) continue; RenderQuery::Ptr query = RenderQuery::Create(); sceneManager->GetRenderQuery(camNode->GetComponent<Camera>()->GetFrustum(), query); query->Sort(camNode->GetWorldPosition(), false); queries.emplace(camNode->GetName(), query); } // draw passes for (unsigned int i = 0; i < m_SortedPasses.size(); i++) { auto passName = m_SortedPasses[i]; auto pass = m_PassMap[passName]; auto drawMode = pass->GetDrawMode(); m_CurrentCamera = pass->GetCameraNode(); m_CurrentShader = pass->GetFirstShader(); if (m_CurrentCamera == nullptr) continue; auto query = queries[m_CurrentCamera->GetName()]; pass->Bind(); if (drawMode == DrawMode::RENDERABLE) { for (const auto &node : query->OpaqueNodes) DrawRenderable(pass, node); } else if (drawMode == DrawMode::LIGHT) { glDepthMask(GL_FALSE); for (const auto &node : query->LightNodes) DrawLight(pass, node); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glCullFace(GL_BACK); } else { DrawQuad(pass); } pass->UnBind(); } // post m_CurrentCamera = nullptr; m_CurrentShader = nullptr; }
void CCTextureFontPage::renderText3D(const char *text, const uint length, const float x, const float y, const float z, const float height, const bool centeredX) const { #if defined PROFILEON CCProfiler profile( "CCTextureFontPage::renderText3D()" ); #endif // TODO: I draw these wrong, please fix me to work with back face culling glCullFace( GL_FRONT ); ASSERT( length < MAX_TEXT_LENGTH ); bindTexturePage(); // Find out our width so we can center the text int lineIndex = 0; CCPoint lineSize[MAX_TEXT_LINES]; static CCPoint charSize[MAX_TEXT_LINES][MAX_TEXT_LENGTH]; int characterIndex = 0; for( uint i=0; i<length; ++i ) { char character = text[i]; if( character == '\n' ) { lineIndex++; characterIndex = 0; ASSERT( lineIndex < MAX_TEXT_LINES ); } else { const Letter *letter = getLetter( character ); if( letter != NULL ) { CCPoint &size = charSize[lineIndex][characterIndex]; size.x = letter->size.width * height; size.y = letter->size.height * height; lineSize[lineIndex].x += size.x; lineSize[lineIndex].y = MAX( lineSize[lineIndex].y, size.y ); characterIndex++; } } } CCPoint start( x, y ); if( centeredX ) { start.x -= lineSize[0].x * 0.5f; } start.y += lineSize[0].y * 0.5f; static CCVector3 currentStart, currentEnd; currentStart.x = start.x; currentStart.y = start.y; currentStart.z = -z; currentEnd.z = z; CCSetTexCoords( texCoords ); lineIndex = 0; characterIndex = 0; for( uint i=0; i<length; ++i ) { char character = text[i]; if( character == '\n' ) { currentStart.x = start.x; currentStart.y -= lineSize[lineIndex].y; lineIndex++; characterIndex = 0; } else { const Letter *letter = getLetter( character ); if( letter != NULL ) { CCPoint &size = charSize[lineIndex][characterIndex]; // Calculate end point currentEnd.x = currentStart.x + size.x; currentEnd.y = currentStart.y - size.y; texCoords[0] = letter->start.x; texCoords[1] = letter->start.y; texCoords[2] = letter->end.x; texCoords[3] = letter->start.y; texCoords[4] = letter->start.x; texCoords[5] = letter->end.y; texCoords[6] = letter->end.x; texCoords[7] = letter->end.y; CCRenderSquare( currentStart, currentEnd ); currentStart.x += size.x; characterIndex++; } } } glCullFace( GL_BACK ); }
// ------------------------------------------------------------------------------------------ //! Function would be called on the global initialization step. //! @returns Non-negative value if the operation succeeded. GDAPI IResult IGraphicsOpenGL::OnRuntimeInitialize() { // _CheckNotInitialized(); ConsoleDevice->Log(GD_DLOG_CAT ": going to initialize graphics devices..."); IResult const _BaseResult = IGraphicsOpenGLPlatform::OnRuntimeInitialize(); if (IFailed(_BaseResult)) return _BaseResult; // Loading OpenGL core profile methods. glewExperimental = GL_TRUE; glewInit(); #if GD_DEBUG if (GLEW_ARB_debug_output) { // We have some good debugging extension running, so we do not need to check for OpenGL // errors after every single OpenGL API function call. // http://www.opengl.org/registry/specs/ARB/debug_output.txt glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); glDebugMessageCallbackARB([](GLenum const Source, GLenum const Type, GLuint const ID, GLenum const Severity , GLsizei const Length, GLchar const* const Message, CHandle const UserParam) { CStr glDebugSeverity; switch (Severity) { default: glDebugSeverity = "Unknown severity"; break; case GL_DEBUG_SEVERITY_HIGH_ARB: glDebugSeverity = "High priority"; break; case GL_DEBUG_SEVERITY_MEDIUM_ARB: glDebugSeverity = "Medium priority"; break; case GL_DEBUG_SEVERITY_LOW_ARB: glDebugSeverity = "Low priority"; break; } CStr glDebugErrorType; switch (Type) { default: glDebugErrorType = "something"; break; case GL_DEBUG_TYPE_OTHER_ARB: glDebugErrorType = "other issue"; break; case GL_DEBUG_TYPE_ERROR_ARB: glDebugErrorType = "error"; break; case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: glDebugErrorType = "deprecated behavior issue"; break; case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: glDebugErrorType = "undefined behavior issue"; break; case GL_DEBUG_TYPE_PORTABILITY_ARB: glDebugErrorType = "portability issue"; break; case GL_DEBUG_TYPE_PERFORMANCE_ARB: glDebugErrorType = "performance issue"; break; } CStr glDebugErrorSource; switch (Source) { default: glDebugErrorSource = "unknown location"; break; case GL_DEBUG_SOURCE_API_ARB: glDebugErrorSource = "API call"; break; case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: glDebugErrorSource = "window system API all"; break; case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: glDebugErrorSource = "shader compiler"; break; case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: glDebugErrorSource = "third party API"; break; case GL_DEBUG_SOURCE_APPLICATION_ARB: glDebugErrorSource = "application"; break; case GL_DEBUG_SOURCE_OTHER_ARB: glDebugErrorSource = "other"; break; } GD_NOT_USED_L(UserParam, Length); switch (Severity) { default: case GL_DEBUG_SEVERITY_LOW_ARB: // Possibly, this is not an error: e.g. a log from NVidia driver. ConsoleDevice->LogFormat(GD_DLOG_CAT ": ... debug callback:\n\t%s %s #%x in %s:\n\t%s" , glDebugSeverity, glDebugErrorType, ID, glDebugErrorSource, Message ); break; case GL_DEBUG_SEVERITY_HIGH_ARB: case GL_DEBUG_SEVERITY_MEDIUM_ARB: // This is some kind of warning or error. ConsoleDevice->LogErrorFormat(GD_DLOG_CAT ": ... debug callback:\n\t%s %s #%x in %s:\n\t%s" , glDebugSeverity, glDebugErrorType, ID, glDebugErrorSource, Message ); GD_ASSERT_FALSE("Some issue inside OpenGL code."); // break; } }, nullptr); } else { ConsoleDevice->LogError(GD_DLOG_CAT ": ... no 'ARB_debug_output' extension was found. No log or error checking for OpenGL code " "would be provided."); } #endif // if GD_DEBUG // Enabling the back-face cooling. glEnable(GL_CULL_FACE); glCullFace(GL_BACK); // We are using m_Left-handed math and clockwise triangles. glFrontFace(GL_CW); // Initially setting up the view-port and depth. glEnable(GL_DEPTH_TEST); glClearDepth(1.0f); glClearColor(0.3f, 0.275f, 1.0f, 1.0f); glViewport(0, 0, GfxResolutionSelected->Width, GfxResolutionSelected->Height); ConsoleDevice->Log(GD_DLOG_CAT ": ... initialized."); return IResult::Ok; }
int main () { GLFWwindow* window = NULL; const GLubyte* renderer; const GLubyte* version; GLuint shader_programme; GLuint vao; // // Start OpenGL using helper libraries // -------------------------------------------------------------------------- if (!glfwInit ()) { fprintf (stderr, "ERROR: could not start GLFW3\n"); return 1; } // change to 3.2 if on Apple OS X glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint (GLFW_SAMPLES, msaa); window = glfwCreateWindow (gl_width, gl_height, "Textured Mesh", NULL, NULL); if (!window) { fprintf (stderr, "ERROR: opening OS window\n"); return 1; } glfwMakeContextCurrent (window); glewExperimental = GL_TRUE; glewInit (); /* get version info */ renderer = glGetString (GL_RENDERER); /* get renderer string */ version = glGetString (GL_VERSION); /* version as a string */ printf ("Renderer: %s\n", renderer); printf ("OpenGL version supported %s\n", version); int point_count = 0; // // Set up vertex buffers and vertex array object // -------------------------------------------------------------------------- { GLfloat* vp = NULL; // array of vertex points GLfloat* vn = NULL; // array of vertex normals (we haven't used these yet) GLfloat* vt = NULL; // array of texture coordinates (or these) //assert (load_obj_file ("cube.obj", vp, vt, vn, point_count)); assert (load_obj_file ("monkey.obj", vp, vt, vn, point_count)); GLuint points_vbo, texcoord_vbo, normal_vbo; glGenBuffers (1, &points_vbo); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count, vp, GL_STATIC_DRAW); glGenBuffers (1, &texcoord_vbo); glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 2 * point_count, vt, GL_STATIC_DRAW); glGenBuffers (1, &normal_vbo); glBindBuffer (GL_ARRAY_BUFFER, normal_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count, vn, GL_STATIC_DRAW); glGenVertexArrays (1, &vao); glBindVertexArray (vao); glEnableVertexAttribArray (0); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (1); glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo); glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (2); glBindBuffer (GL_ARRAY_BUFFER, normal_vbo); glVertexAttribPointer (2, 3, GL_FLOAT, GL_FALSE, 0, NULL); free (vp); free (vn); free (vt); } // // Load shaders from files // -------------------------------------------------------------------------- { char* vertex_shader_str; char* fragment_shader_str; // allocate some memory to store shader strings vertex_shader_str = (char*)malloc (81920); fragment_shader_str = (char*)malloc (81920); // load shader strings from text files assert (parse_file_into_str ("teapot.vert", vertex_shader_str, 81920)); assert (parse_file_into_str ("teapot.frag", fragment_shader_str, 81920)); GLuint vs, fs; vs = glCreateShader (GL_VERTEX_SHADER); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL); glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL); // free memory free (vertex_shader_str); free (fragment_shader_str); int params = -1; glCompileShader (vs); glGetShaderiv (vs, GL_COMPILE_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: GL shader index %i (teapot.vert) did not compile\n", vs); int max_length = 2048; int actual_length = 0; char log[2048]; glGetShaderInfoLog (vs, max_length, &actual_length, log); printf ("shader info log for GL index %u\n%s\n", vs, log); } glCompileShader (fs); glGetShaderiv (fs, GL_COMPILE_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: GL shader index %i (teapot.frag) did not compile\n", fs); int max_length = 2048; int actual_length = 0; char log[2048]; glGetShaderInfoLog (fs, max_length, &actual_length, log); printf ("shader info log for GL index %u\n%s\n", vs, log); } shader_programme = glCreateProgram (); glAttachShader (shader_programme, fs); glAttachShader (shader_programme, vs); glBindAttribLocation (shader_programme, 0, "vp"); glBindAttribLocation (shader_programme, 1, "vt"); glBindAttribLocation (shader_programme, 2, "vn"); glLinkProgram (shader_programme); glGetProgramiv (shader_programme, GL_LINK_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: could not link shader programme GL index %u\n", shader_programme); int max_length = 2048; int actual_length = 0; char log[2048]; glGetProgramInfoLog (shader_programme, max_length, &actual_length, log); printf ("program info log for GL index %u\n%s\n", shader_programme, log); } /* TODO NOTE: you should check for errors and print logs after compiling and also linking shaders */ } // // Create some matrices // -------------------------------------------------------------------------- mat4 M, V, P; M = identity_mat4 ();//scale (identity_mat4 (), vec3 (0.05, 0.05, 0.05)); vec3 cam_pos (0.0, 5.0, 5.0); vec3 targ_pos (0.0, 0.0, 0.0); vec3 up = normalise (vec3 (0.0, 1.0, -1.0)); V = look_at (cam_pos, targ_pos, up); P = perspective (67.0f, (float)gl_width / (float)gl_height, 0.1, 10.0); int M_loc = glGetUniformLocation (shader_programme, "M"); int V_loc = glGetUniformLocation (shader_programme, "V"); int P_loc = glGetUniformLocation (shader_programme, "P"); int ol_loc = glGetUniformLocation (shader_programme, "ol_mode"); int sm_loc = glGetUniformLocation (shader_programme, "sm_shaded"); // send matrix values to shader immediately glUseProgram (shader_programme); glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m); glUniformMatrix4fv (V_loc, 1, GL_FALSE, V.m); glUniformMatrix4fv (P_loc, 1, GL_FALSE, P.m); glUniform1f (ol_loc, 0.0f); glUniform1f (sm_loc, 0.0f); // // Start rendering // -------------------------------------------------------------------------- // tell GL to only draw onto a pixel if the fragment is closer to the viewer glEnable (GL_DEPTH_TEST); // enable depth-testing glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer" glDepthFunc (GL_LESS); // depth-testing is to use a "less than" function glEnable (GL_CULL_FACE); // enable culling of faces glCullFace (GL_BACK); glFrontFace (GL_CCW); glClearColor (0.04, 0.04, 0.75, 1.0); bool multi_pass = true; GLuint fb, c_tex, d_tex;; { // fb glGenFramebuffers (1, &fb); glBindFramebuffer (GL_FRAMEBUFFER, fb); glGenTextures (1, &c_tex); glGenTextures (1, &d_tex); glActiveTexture (GL_TEXTURE0); glBindTexture (GL_TEXTURE_2D, c_tex); glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, gl_width, gl_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, c_tex, 0); glBindTexture (GL_TEXTURE_2D, d_tex); glTexImage2D (GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, gl_width, gl_height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, d_tex, 0); glBindFramebuffer (GL_FRAMEBUFFER, 0); } GLuint quad_vao; { float quad_pts[] = {-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0}; GLuint quad_vbo; glGenBuffers (1, &quad_vbo); glGenVertexArrays (1, &quad_vao); glBindVertexArray (quad_vao); glEnableVertexAttribArray (0); glBindBuffer (GL_ARRAY_BUFFER, quad_vbo); glBufferData (GL_ARRAY_BUFFER, 8 * sizeof (float), quad_pts, GL_STATIC_DRAW); glVertexAttribPointer (0, 2, GL_FLOAT, GL_FALSE, 0, NULL); } GLuint post_sp; { char* vertex_shader_str; char* fragment_shader_str; // allocate some memory to store shader strings vertex_shader_str = (char*)malloc (81920); fragment_shader_str = (char*)malloc (81920); // load shader strings from text files assert (parse_file_into_str ("post.vert", vertex_shader_str, 81920)); assert (parse_file_into_str ("post.frag", fragment_shader_str, 81920)); GLuint vs, fs; vs = glCreateShader (GL_VERTEX_SHADER); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL); glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL); // free memory free (vertex_shader_str); free (fragment_shader_str); int params = -1; glCompileShader (vs); glGetShaderiv (vs, GL_COMPILE_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: GL shader index %i (post.vert) did not compile\n", vs); int max_length = 2048; int actual_length = 0; char log[2048]; glGetShaderInfoLog (vs, max_length, &actual_length, log); printf ("shader info log for GL index %u\n%s\n", vs, log); } glCompileShader (fs); glGetShaderiv (fs, GL_COMPILE_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: GL shader index %i (post.frag) did not compile\n", fs); int max_length = 2048; int actual_length = 0; char log[2048]; glGetShaderInfoLog (fs, max_length, &actual_length, log); printf ("shader info log for GL index %u\n%s\n", vs, log); } post_sp = glCreateProgram (); glAttachShader (post_sp, fs); glAttachShader (post_sp, vs); glBindAttribLocation (post_sp, 0, "vp"); glLinkProgram (post_sp); glGetProgramiv (post_sp, GL_LINK_STATUS, ¶ms); if (GL_TRUE != params) { printf ("ERROR: could not link shader programme GL index %u\n", post_sp); int max_length = 2048; int actual_length = 0; char log[2048]; glGetProgramInfoLog (post_sp, max_length, &actual_length, log); printf ("program info log for GL index %u\n%s\n", post_sp, log); } } double a = 0.0f; double prev = glfwGetTime (); while (!glfwWindowShouldClose (window)) { if (multi_pass) { glBindFramebuffer (GL_FRAMEBUFFER, fb); } glViewport (0, 0, gl_width, gl_height); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glActiveTexture (GL_TEXTURE0); glBindTexture (GL_TEXTURE_2D, 0); double curr = glfwGetTime (); double elapsed = curr - prev; prev = curr; glUseProgram (shader_programme); glBindVertexArray (vao); a += elapsed * 50.0f; //float ang = (float)sin (a); M = rotate_y_deg (identity_mat4 (), a); glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m); glUniform1f (sm_loc, 1.0f); // smooth shaded or not (exception is flat-shaded, they might not be great // if non-cube anyway due to scaling) if (!multi_pass) { glFrontFace (GL_CW); glUniform1f (ol_loc, 1.0f); glDrawArrays (GL_TRIANGLES, 0, point_count); } glFrontFace (GL_CCW); glUniform1f (ol_loc, 0.0f); glDrawArrays (GL_TRIANGLES, 0, point_count); /* this just updates window events and keyboard input events (not used yet) */ if (multi_pass) { glFlush (); glFinish (); glBindFramebuffer (GL_FRAMEBUFFER, 0); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport (0, 0, gl_width, gl_height); glUseProgram (post_sp); glActiveTexture (GL_TEXTURE0); glBindTexture (GL_TEXTURE_2D, d_tex); glBindVertexArray (quad_vao); glDrawArrays (GL_TRIANGLE_STRIP, 0, 4); } glfwPollEvents (); glfwSwapBuffers (window); } return 0; }
static void drawAllViews(void) { const GLfloat light_position[4] = {0.0f, 8.0f, 8.0f, 1.0f}; const GLfloat light_diffuse[4] = {1.0f, 1.0f, 1.0f, 1.0f}; const GLfloat light_specular[4] = {1.0f, 1.0f, 1.0f, 1.0f}; const GLfloat light_ambient[4] = {0.2f, 0.2f, 0.3f, 1.0f}; double aspect; // Calculate aspect of window if (height > 0) aspect = (double) width / (double) height; else aspect = 1.0; // Clear screen glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Enable scissor test glEnable(GL_SCISSOR_TEST); // Enable depth test glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // ** ORTHOGONAL VIEWS ** // For orthogonal views, use wireframe rendering glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Enable line anti-aliasing glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Setup orthogonal projection matrix glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-3.0 * aspect, 3.0 * aspect, -3.0, 3.0, 1.0, 50.0); // Upper left view (TOP VIEW) glViewport(0, height / 2, width / 2, height / 2); glScissor(0, height / 2, width / 2, height / 2); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0f, 10.0f, 1e-3f, // Eye-position (above) 0.0f, 0.0f, 0.0f, // View-point 0.0f, 1.0f, 0.0f); // Up-vector drawGrid(0.5, 12); drawScene(); // Lower left view (FRONT VIEW) glViewport(0, 0, width / 2, height / 2); glScissor(0, 0, width / 2, height / 2); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0f, 0.0f, 10.0f, // Eye-position (in front of) 0.0f, 0.0f, 0.0f, // View-point 0.0f, 1.0f, 0.0f); // Up-vector drawGrid(0.5, 12); drawScene(); // Lower right view (SIDE VIEW) glViewport(width / 2, 0, width / 2, height / 2); glScissor(width / 2, 0, width / 2, height / 2); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(10.0f, 0.0f, 0.0f, // Eye-position (to the right) 0.0f, 0.0f, 0.0f, // View-point 0.0f, 1.0f, 0.0f); // Up-vector drawGrid(0.5, 12); drawScene(); // Disable line anti-aliasing glDisable(GL_LINE_SMOOTH); glDisable(GL_BLEND); // ** PERSPECTIVE VIEW ** // For perspective view, use solid rendering glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Enable face culling (faster rendering) glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); // Setup perspective projection matrix glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(65.0f, aspect, 1.0f, 50.0f); // Upper right view (PERSPECTIVE VIEW) glViewport(width / 2, height / 2, width / 2, height / 2); glScissor(width / 2, height / 2, width / 2, height / 2); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(3.0f, 1.5f, 3.0f, // Eye-position 0.0f, 0.0f, 0.0f, // View-point 0.0f, 1.0f, 0.0f); // Up-vector // Configure and enable light source 1 glLightfv(GL_LIGHT1, GL_POSITION, light_position); glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular); glEnable(GL_LIGHT1); glEnable(GL_LIGHTING); // Draw scene drawScene(); // Disable lighting glDisable(GL_LIGHTING); // Disable face culling glDisable(GL_CULL_FACE); // Disable depth test glDisable(GL_DEPTH_TEST); // Disable scissor test glDisable(GL_SCISSOR_TEST); // Draw a border around the active view if (active_view > 0 && active_view != 2) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f); glColor3f(1.0f, 1.0f, 0.6f); glBegin(GL_LINE_STRIP); glVertex2i(0, 0); glVertex2i(1, 0); glVertex2i(1, 1); glVertex2i(0, 1); glVertex2i(0, 0); glEnd(); } }
/*!**************************************************************************** @Function InitView @Return bool true if no error occured @Description Code in InitView() will be called by PVRShell upon initialization or after a change in the rendering context. Used to initialize variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.) ******************************************************************************/ bool OGLES2PVRScopeRemote::InitView() { CPVRTString ErrorStr; /* Initialize VBO data */ LoadVbos(); /* Load textures */ if (!LoadTextures(&ErrorStr)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Take our initial vert shader source { CPVRTResourceFile VertShaderFile(c_szVertShaderSrcFile); m_pszVertShader = new char[VertShaderFile.Size() + 1]; strncpy(m_pszVertShader, (char*)VertShaderFile.DataPtr(), VertShaderFile.Size()); m_pszVertShader[VertShaderFile.Size()] = 0; } // Take our initial frag shader source { CPVRTResourceFile FragShaderFile(c_szFragShaderSrcFile); m_pszFragShader = new char[FragShaderFile.Size() + 1]; strncpy(m_pszFragShader, (char*)FragShaderFile.DataPtr(), FragShaderFile.Size()); m_pszFragShader[FragShaderFile.Size()] = 0; } /* Load and compile the shaders & link programs */ if (!LoadShaders(&ErrorStr, m_pszFragShader, m_pszVertShader)) { PVRShellSet(prefExitMessage, ErrorStr.c_str()); return false; } // Is the screen rotated? bool bRotate = PVRShellGet(prefIsRotated) && PVRShellGet(prefFullScreen); /* Initialize Print3D */ if(m_Print3D.SetTextures(0,PVRShellGet(prefWidth),PVRShellGet(prefHeight), bRotate) != PVR_SUCCESS) { PVRShellSet(prefExitMessage, "ERROR: Cannot initialise Print3D\n"); return false; } /* Calculate the projection and view matrices */ m_mProjection = PVRTMat4::PerspectiveFovRH(PVRT_PI/6, (float)PVRShellGet(prefWidth)/(float)PVRShellGet(prefHeight), CAM_NEAR, CAM_FAR, PVRTMat4::OGL, bRotate); m_mView = PVRTMat4::LookAtRH(PVRTVec3(0, 0, 75), PVRTVec3(0, 0, 0), PVRTVec3(0, 1, 0)); /* Set OpenGL ES render states needed for this training course */ // Enable backface culling and depth test glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); // Use a nice bright blue as clear colour glClearColor(0.6f, 0.8f, 1.0f, 1.0f); return true; }
static Bool tdPaintWindowWithDepth (CompWindow *w, const WindowPaintAttrib *attrib, const CompTransform *transform, Region region, unsigned int mask) { //Bool wasCulled; Bool status; int wx, wy, ww, wh; int bevel, cull, cullInv, temp; CompScreen *s = w->screen; CompVector point, tPoint; unsigned short c[4]; TD_SCREEN (s); TD_WINDOW (w); CUBE_SCREEN (s); //wasCulled = glIsEnabled (GL_CULL_FACE); wx = w->attrib.x - w->input.left; wy = w->attrib.y - w->input.top; ww = w->width + w->input.left + w->input.right; wh = w->height + w->input.top + w->input.bottom; const BananaValue * option_bevel = bananaGetOption (bananaIndex, "bevel", s->screenNum); bevel = option_bevel->i; glGetIntegerv (GL_CULL_FACE_MODE, &cull); cullInv = (cull == GL_BACK)? GL_FRONT : GL_BACK; if (ww && wh && !(mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK) && ((cs->paintOrder == FTB && tdw->ftb) || (cs->paintOrder == BTF && !tdw->ftb))) { /* Paint window depth. */ glPushMatrix (); glLoadIdentity (); if (cs->paintOrder == BTF) glCullFace (cullInv); glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); if (w->id == display.activeWindow) { const BananaValue * option_width_color = bananaGetOption (bananaIndex, "width_color", s->screenNum); stringToColor (option_width_color->s, c); } else { const BananaValue * option_width_color_inactive = bananaGetOption (bananaIndex, "width_color_inactive", s->screenNum); stringToColor (option_width_color_inactive->s, c); } temp = c[3] * w->paint.opacity; temp /= 0xffff; glColor4us (c[0], c[1], c[2], temp); point.z = 0.0f; point.w = 1.0f; glBegin (GL_QUADS); /* Top */ ADDQUAD (wx + ww - dobevel ("bevel_topleft", bevel), wy + 0.01, wx + dobevel ("bevel_topright", bevel), wy + 0.01); /* Bottom */ ADDQUAD ( wx + dobevel ("bevel_bottomleft", bevel), wy + wh - 0.01, wx + ww - dobevel ("bevel_bottomright", bevel), wy + wh - 0.01); /* Left */ ADDQUAD (wx + 0.01, wy + dobevel ("bevel_topleft", bevel), wx + 0.01, wy + wh - dobevel ("bevel_bottomleft", bevel)); /* Right */ ADDQUAD (wx + ww - 0.01, wy + wh - dobevel ("bevel_topright", bevel), wx + ww - 0.01, wy + dobevel ("bevel_bottomright", bevel)); const BananaValue * option_bevel_topleft = bananaGetOption (bananaIndex, "bevel_topleft", s->screenNum); /* Top left bevel */ if (option_bevel_topleft->b) { ADDBEVELQUAD (wx + bevel / 2.0f, wy + bevel - bevel / 1.2f, wx, wy + bevel, &tds->bTransform, transform); ADDBEVELQUAD (wx + bevel / 2.0f, wy + bevel - bevel / 1.2f, wx + bevel, wy, transform, &tds->bTransform); } const BananaValue * option_bevel_bottomleft = bananaGetOption (bananaIndex, "bevel_bottomleft", s->screenNum); /* Bottom left bevel */ if (option_bevel_bottomleft->b) { ADDBEVELQUAD (wx + bevel / 2.0f, wy + wh - bevel + bevel / 1.2f, wx, wy + wh - bevel, transform, &tds->bTransform); ADDBEVELQUAD (wx + bevel / 2.0f, wy + wh - bevel + bevel / 1.2f, wx + bevel, wy + wh, &tds->bTransform, transform); } const BananaValue * option_bevel_bottomright = bananaGetOption (bananaIndex, "bevel_bottomright", s->screenNum); /* Bottom right bevel */ if (option_bevel_bottomright->b) { ADDBEVELQUAD (wx + ww - bevel / 2.0f, wy + wh - bevel + bevel / 1.2f, wx + ww - bevel, wy + wh, transform, &tds->bTransform); ADDBEVELQUAD (wx + ww - bevel / 2.0f, wy + wh - bevel + bevel / 1.2f, wx + ww, wy + wh - bevel, &tds->bTransform, transform); } const BananaValue * option_bevel_topright = bananaGetOption (bananaIndex, "bevel_topright", s->screenNum); /* Top right bevel */ if (option_bevel_topright->b) { ADDBEVELQUAD (wx + ww - bevel, wy, wx + ww - bevel / 2.0f, wy + bevel - bevel / 1.2f, transform, &tds->bTransform); ADDBEVELQUAD (wx + ww, wy + bevel, wx + ww - bevel / 2.0f, wy + bevel - bevel / 1.2f, &tds->bTransform, transform); } glEnd (); glColor4usv (defaultColor); glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glPopMatrix (); if (cs->paintOrder == BTF) glCullFace (cull); } UNWRAP(tds, s, paintWindow); if (cs->paintOrder == BTF) status = (*s->paintWindow) (w, attrib, transform, region, mask); else status = (*s->paintWindow) (w, attrib, &tds->bTransform, region, mask | PAINT_WINDOW_TRANSFORMED_MASK); WRAP (tds, s, paintWindow, tdPaintWindow); return status; }
/** * Dibuje el modelo definido por el archivo knight.obj 1 disponible en webasignatura. El * formato del archivo OBJ se encuentra definido en el anexo I de este documento. Cada * triángulo del modelo debe ser dibujado usando un tono de gris randómico en sus vértices. * Nota: Para parsear el archivo obj, puede utilizar las funciones fgets (definida en stdio.h), * strcmp, strtok (definidas en string.h), atof y atoi (definidas en stdlib.h). */ int main(int argc, char* argv[]) { // Crear una ventana de 500x500 pixels: int cw = 900; int ch = 900; cg_init(cw, ch, NULL); #ifdef WIN32 freopen( "CON", "w", stdout ); freopen( "CON", "w", stderr ); #endif printf("GL Version: %s\n", glGetString(GL_VERSION)); // Actualizar la pantalla: glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glViewport(0,0,cw, ch); glFrustum(-1,1,-1,1,1,1000); //Habilito la iluminación del pipeline estático de OpenGL. glEnable(GL_LIGHTING); //Creo un Vec4 para representar el color (RGBA) y la Intensidad de la luz. //P.e.: (1,1,1,1) = Luz Blanca intensa, (0.5,0.5,0.5,1) = Luz blanca tenue, (0.5,0,0,1) = Luz roja tenue. float l0[] = {1.0f,1.0f,1.0f,1.0f}; //Creo un Vec4 para representar el color (RGBA) y la intensidad de la iluminación ambiente de la luz float la[] = {0.10f,0.10f,0.10f,1.0f}; //Creo un Vec4 para representar la posición de la luz. El cuarto elemento representa el tipo de luz: 1=puntual, 0=direccional float l0p[]= {1.0f,1.0f,1.0f,1.0f}; //Creo un Vec4 para representar el color (RGBA) y la intensidad especular de la luz float ls[] = {1.0f,1.0f,1.0f,1.0f}; //Cargo la intesidad ambiente de la Luz Nro 0 del pipline estático. glLightfv(GL_LIGHT0, GL_AMBIENT, la); //Cargo la intesidad difusa de la Luz Nro 0 del pipline estático. glLightfv(GL_LIGHT0, GL_DIFFUSE, l0); //Cargo la posición de la Luz Nro 0 del pipline estático. glLightfv(GL_LIGHT0, GL_POSITION, l0p); //Cargo la intesidad especular de la Luz Nro 0 del pipline estático. glLightfv(GL_LIGHT0, GL_SPECULAR, ls); //Prendo la Luz nro 0 del pipline estático. Hay 8 luces, representadas por las constantes GL_LIGHT0 a GL_LIGHT7 //Por defecto está todas apagadas al inicio. glEnable(GL_LIGHT0); //Creo un Vec4 para representar el color difuso(RGBA) del material del objeto a dibujar. float cyan[] = {1.0f, 0.0f, 1.0f, 1.f}; //Cargo el color difuso del la cara de adelante del objeto a dibujar. glMaterialfv(GL_FRONT, GL_DIFFUSE, cyan); //Cargo el color especular del la cara de adelante del objeto a dibujar. glMaterialfv(GL_FRONT, GL_SPECULAR, ls); //Cargo el coeficiente especular de la cara de adelante del objeto a dibujar. glMateriali(GL_FRONT, GL_SHININESS, 32); float ang = 0.0f; float pitch = 0.0f; float ang_vel = 1.0f; Obj* obj = obj_load("Models/knight.obj"); printf("num of faces %d\n", obj->numfaces); // delete printf("num of vertices %d\n", obj->numverts); // delete char done = 0; char wireframe = 0; char bfc = 0; glEnable(GL_DEPTH_TEST); char zbuff = 1; unsigned char key_pressed[1024]; memset(key_pressed, 0, 1024); while (!done) { SDL_Event event; while(SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: key_pressed[event.key.keysym.sym] = 1; if (event.key.keysym.sym == SDLK_z) { zbuff = !zbuff; if(zbuff) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); break; } else if (event.key.keysym.sym == SDLK_m) { wireframe = !wireframe; if(wireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; } else if (event.key.keysym.sym == SDLK_b) { bfc = !bfc; if(bfc) { glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); } else glDisable(GL_CULL_FACE); break; } else if (event.key.keysym.sym != SDLK_ESCAPE) break; case SDL_QUIT : done = 1;break; case SDL_KEYUP: key_pressed[event.key.keysym.sym] = 0; } } glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0f, 0.0f, -50.0f); glRotatef(pitch, 1.0f, 0.0f, 0.0f); glRotatef(ang, 0.0f, 1.0f, 0.0f); glRotatef(-90.0f, 1.0f, 0.0f, 0.0f); if(key_pressed[SDLK_RIGHT]) ang += ang_vel; if(key_pressed[SDLK_LEFT]) ang -= ang_vel; if(key_pressed[SDLK_UP]) pitch += ang_vel; if(key_pressed[SDLK_DOWN]) pitch -= ang_vel; glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); obj_render(obj); cg_repaint(); } obj_free(obj); // Liberar recursos: cg_close(); // Ejemplo del modulo de Manejo de Memoria (MM): int* pint = (int *)cg_malloc(10*sizeof(int)); printf("pint is a pointer: %p\n", pint); cg_free(pint); // olvidarse de liberar este objeto produce un mensaje return 0; }
static void pie_DrawShadows(void) { const float width = pie_GetVideoBufferWidth(); const float height = pie_GetVideoBufferHeight(); GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR; pie_SetTexturePage(TEXPAGE_NONE); glPushMatrix(); pie_SetAlphaTest(false); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthFunc(GL_LESS); glDepthMask(GL_FALSE); glEnable(GL_STENCIL_TEST); // Check if we have the required extensions if (GLEE_EXT_stencil_wrap) { op_depth_pass_front = GL_INCR_WRAP_EXT; op_depth_pass_back = GL_DECR_WRAP_EXT; } // generic 1-pass version if (GLEE_EXT_stencil_two_side) { glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT); glDisable(GL_CULL_FACE); glStencilMask(~0); glActiveStencilFaceEXT(GL_BACK); glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back); glStencilFunc(GL_ALWAYS, 0, ~0); glActiveStencilFaceEXT(GL_FRONT); glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front); glStencilFunc(GL_ALWAYS, 0, ~0); pie_ShadowDrawLoop(); glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT); } // check for ATI-specific 1-pass version else if (GLEE_ATI_separate_stencil) { glDisable(GL_CULL_FACE); glStencilMask(~0); glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back); glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front); glStencilFunc(GL_ALWAYS, 0, ~0); pie_ShadowDrawLoop(); } // fall back to default 2-pass version else { glStencilMask(~0); glStencilFunc(GL_ALWAYS, 0, ~0); glEnable(GL_CULL_FACE); // Setup stencil for front-facing polygons glCullFace(GL_BACK); glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front); pie_ShadowDrawLoop(); // Setup stencil for back-facing polygons glCullFace(GL_FRONT); glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back); pie_ShadowDrawLoop(); } pie_SetRendMode(REND_ALPHA); glEnable(GL_CULL_FACE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); glStencilMask(~0); glStencilFunc(GL_LESS, 0, ~0); glColor4f(0, 0, 0, 0.5); pie_PerspectiveEnd(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glBegin(GL_TRIANGLE_STRIP); glVertex2f(0, 0); glVertex2f(width, 0); glVertex2f(0, height); glVertex2f(width, height); glEnd(); pie_PerspectiveBegin(); pie_SetRendMode(REND_OPAQUE); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glPopMatrix(); nb_scshapes = 0; }