// the program starts here void AppMain() { // initialise GLFW glfwSetErrorCallback(OnError); if(!glfwInit()) throw std::runtime_error("glfwInit failed"); // open a window with GLFW glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); gWindow = glfwCreateWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, "Mek", NULL /*glfwGetPrimaryMonitor()*/, NULL); if (!gWindow) throw std::runtime_error("glfwCreateWindow failed. Can your hardware handle OpenGL 3.3?"); // GLFW settings glfwSetInputMode(gWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED); glfwSetCursorPos(gWindow, 0, 0); glfwSetScrollCallback(gWindow, OnScroll); glfwMakeContextCurrent(gWindow); // required or we crash on VAO creation glewExperimental = GL_TRUE; // initialise GLEW if (glewInit() != GLEW_OK) { throw std::runtime_error("glewInit failed"); } // GLEW throws some errors so discard all the errors so far while(glGetError() != GL_NO_ERROR) {} // Init DevIL ilInit(); // enable vsync using windows only code #ifdef _WIN32 // Turn on vertical screen sync under Windows. typedef BOOL(WINAPI *PFNWGLSWAPINTERVALEXTPROC)(int interval); PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL; wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT"); if (wglSwapIntervalEXT) wglSwapIntervalEXT(1); #endif // print out some info about the graphics drivers std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl; std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl; std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl; std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl; // make sure OpenGL version 3.2 API is available if(!GLEW_VERSION_3_3) throw std::runtime_error("OpenGL 3.3 API is not available."); // OpenGL settings glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // initialise the gWoodenCrate asset LoadWoodenCrateAsset(); // create all the instances in the 3D scene based on the gWoodenCrate asset CreateInstances(); // setup Camera::getInstance() Camera::getInstance().setPosition(glm::vec3(1100, 75, 0)); Camera::getInstance().setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y); Camera::getInstance().setNearAndFarPlanes(1.f, 500.0f); Camera::getInstance().setFieldOfView(179); crosshair = new twodOverlay("crosshair.png", 0, 0, 1); skull = new twodOverlayAnim("killSkull.png", 5, 0.5); startscreen = new twodOverlay("pressStart.png", 0, 0, 10); skull->updatePos(-0.85f, -0.75f, 4); skull ->cycle = true; //MODEL INITS prepProjectiles(); model = new GameObject(0); model->SetName("Moving"); gModel = new ComponentGraphics(); gModel->setOwner(model); gModel->loadModel("models/TallCube.dae"); Component* gp = gModel; model->AddComponent(GRAPHICS, gp); gCol = new ComponentCollision(); gCol->setCollisionMask(gModel->getScene()); gCol->setOwner(model); model->pos = glm::vec3(7.5, 0.5, -11); model->vel = 0.01; model->dir = glm::vec3(1, 0, 0); model->scale = glm::vec3(5, 5, 5); gCol->type = MOVING; gCol->createHitboxRender(); gp = gCol; model->AddComponent(PHYSICS, gp); ComponentInput* ci = new ComponentInput(0.05,0.05); gp = ci; model->AddComponent(CONTROLLER, gp); //PROPER INIT for (int i = 0; i < 22; i++) { if (i != 3 && i != 0 && i != 4 && i != 8 && i != 18 && i != 19 && i != 20 && i !=21) { GameObject *gObject = new GameObject(goVec.size()); ComponentGraphics *cModel = new ComponentGraphics(); ComponentCollision *cCollision = new ComponentCollision(); Component *c; if (i == 0) { gObject->SetName("Spawn Container 1"); cModel->loadModel("models/Container.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(60, 0, -110); } else if (i == 1) { gObject->SetName("Water Tower"); cModel->loadModel("models/Watertower.dae"); gObject->scale = glm::vec3(3, 3, 3); gObject->pos = glm::vec3(-65, 0, -90); } else if (i == 2) { gObject->SetName("MenuScene"); cModel->loadModel("models/Warehouse_One_mesh_No_roof.dae"); gObject->scale = glm::vec3(1, 1, 1);// glm::vec3(1.6, 1.6, 1.6); gObject->pos = glm::vec3(10000, 0, 0); } else if (i == 3) { gObject->SetName("Spawn Container 2"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(85, 0, -75); } else if (i == 4) { gObject->SetName("Middle Plus"); cModel->loadModel("models/Container.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(15, 0, -20); } else if (i == 5) { gObject->SetName("North Wall"); cModel->loadModel("models/Container_Wal_LPl.dae"); gObject->scale = glm::vec3(0.7, 0.70, 0.70); gObject->pos = glm::vec3(100, 0, 165); } else if (i == 6) { gObject->SetName("Dumbster");//Crane cModel->loadModel("models/Dumspter2.dae"); gObject->pos = glm::vec3(0, 0, -140); gObject->scale = glm::vec3(0.4, 0.4, 0.4); } else if (i == 7) { gObject->SetName("Shack"); cModel->loadModel("models/Shack.dae"); gObject->scale = glm::vec3(0.75, 0.75, 0.75); gObject->pos = glm::vec3(0, 0, 120); } else if (i == 8) { gObject->SetName("Middle Plus"); cModel->loadModel("models/Container.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(-5, 0, -20); } else if (i == 9) { gObject->SetName("Container 2"); cModel->loadModel("models/Container.dae"); gObject->scale = glm::vec3(0.70, 0.70, 0.70); gObject->pos = glm::vec3(80, 0, 100); } else if (i == 10) { gObject->SetName("South Wall"); cModel->loadModel("models/Container_Wal_LPl.dae"); gObject->scale = glm::vec3(0.7, 0.70, 0.70); gObject->pos = glm::vec3(-100, 0, 165); } else if (i == 11) { gObject->SetName("East Wall"); cModel->loadModel("models/Container_Wal_LP90.dae"); gObject->scale = glm::vec3(0.7, 0.70, 0.70); gObject->pos = glm::vec3(50, 0, 145); } else if (i == 12) { gObject->SetName("West Wall"); cModel->loadModel("models/Container_Wal_LP90.dae"); gObject->scale = glm::vec3(0.7, 0.70, 0.70); gObject->pos = glm::vec3(50, 0, -125); } else if (i == 13) { gObject->SetName("Container 2"); cModel->loadModel("models/Container.dae"); gObject->scale = glm::vec3(0.70, 0.70, 0.70); gObject->pos = glm::vec3(60, 0, 100); } else if (i == 14) { gObject->SetName("Container 90"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.70, 0.70, 0.70); gObject->pos = glm::vec3(70, 0, 70); } else if (i == 15) { gObject->SetName("Shack"); cModel->loadModel("models/Shack.dae"); gObject->scale = glm::vec3(0.75, 0.75, 0.75); gObject->pos = glm::vec3(-30, 0, 120); } else if (i == 16) { gObject->SetName("Shack"); cModel->loadModel("models/Shack.dae"); gObject->scale = glm::vec3(0.75, 0.75, 0.75); gObject->pos = glm::vec3(30, 0, 120); } else if (i == 17) { gObject->SetName("Shack"); cModel->loadModel("models/Shack.dae"); gObject->scale = glm::vec3(0.75, 0.75, 0.75); gObject->pos = glm::vec3(-60, 0, 120); } else if (i == 18) { gObject->SetName("Middle Plus North"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(27, 0, -5); } else if (i == 19) { gObject->SetName("Middle Plus North"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(27, 0, 15); } else if (i == 20) { gObject->SetName("Middle Plus North"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(-20, 0, 15); } else if (i == 21) { gObject->SetName("Middle Plus North"); cModel->loadModel("models/Container90.dae"); gObject->scale = glm::vec3(0.7, 0.7, 0.7); gObject->pos = glm::vec3(-20, 0, -5); } gObject->pos /= 10.f; cModel->setOwner(gObject); c = cModel; gObject->AddComponent(GRAPHICS, c); cCollision->setOwner(gObject); cCollision->setCollisionMask(cModel->getScene()); cCollision->type = STATIC; cCollision->setCollisionElip(glm::vec3(1, 1, 1)); cCollision->createHitboxRender(); gObject->AddComponent(PHYSICS, cCollision); goVec.push_back(gObject); } } LoadTargets(); spotLightColour = glm::normalize(spotLightColour); for (int i = 0; i < 6; i++) { LightComponent* light; if (i == 0) { light = new LightComponent(lSPOT); SpotLight* lc = new SpotLight; lc->Base.Base.Color = spotLightColour; lc->Base.Base.AmbientIntensity = 0.1f; lc->Base.Base.DiffuseIntensity = 0.1f; lc->Base.Atten.Constant = 0.1f; lc->Base.Atten.Exp = 0.1f; lc->Base.Atten.Linear = 0.1f; lc->Cutoff = 0.75f; lc->Base.Position = glm::vec3(-6, 1, 11); lc->Direction = glm::vec3(0, 0, -1); light->SetVars(lSPOT, lc); } if (i == 1) { light = new LightComponent(lSPOT); SpotLight* lc = new SpotLight; lc->Base.Base.Color = spotLightColour; lc->Base.Base.AmbientIntensity = 0.5f; lc->Base.Base.DiffuseIntensity = 0.5f; lc->Base.Atten.Constant = 0.5f; lc->Base.Atten.Exp = 0.5f; lc->Base.Atten.Linear = 0.5f; lc->Cutoff = 0.75f; lc->Base.Position = glm::vec3(3, 1, 11); lc->Direction = (glm::vec3(0, 0, 10)); light->SetVars(lSPOT, lc); } if (i == 2) { //light = new LightComponent(lSPOT); //SpotLight* lc = new SpotLight; //lc->Base.Base.Color = glm::vec3(0,0.1,0); //lc->Base.Base.AmbientIntensity = 0.5f; //lc->Base.Base.DiffuseIntensity = 0.5f; // //lc->Base.Atten.Constant = 0.5f; //lc->Base.Atten.Exp = 0.5f; //lc->Base.Atten.Linear = 0.5f; // //lc->Cutoff = 0.75f; //lc->Base.Position = glm::vec3(-3, 1, 11); //lc->Direction = (glm::vec3(-3, 0, 12)); // //light->SetVars(lSPOT, lc); } if (i == 3) { //light = new LightComponent(lSPOT); //SpotLight* lc = new SpotLight; //lc->Base.Base.Color = spotLightColour; //lc->Base.Base.AmbientIntensity = 0.5f; //lc->Base.Base.DiffuseIntensity = 0.5f; // //lc->Base.Atten.Constant = 0.5f; //lc->Base.Atten.Exp = 0.5f; //lc->Base.Atten.Linear = 0.5f; // //lc->Cutoff = 0.75f; //lc->Base.Position = glm::vec3(-6, 1, 11); //lc->Direction = (glm::vec3(-6, 1, 12)); // //light->SetVars(lSPOT, lc); } if (i == 4) { //light = new LightComponent(lSPOT); //SpotLight* lc = new SpotLight; //lc->Base.Base.Color = spotLightColour; //lc->Base.Base.AmbientIntensity = 0.1f; //lc->Base.Base.DiffuseIntensity = 0.1f; // //lc->Base.Atten.Constant = 0.1f; //lc->Base.Atten.Exp = 0.1f; //lc->Base.Atten.Linear = 0.1f; // //lc->Cutoff = 0.75f; //lc->Base.Position = glm::vec3(0, 1, 0); //lc->Direction = glm::vec3(0, -1, 0); // //light->SetVars(lSPOT, lc); } if (i == 5) { light = new LightComponent(lSPOT); SpotLight* lc = new SpotLight; lc->Base.Base.Color = spotLightColour; lc->Base.Base.AmbientIntensity = 0.5f; lc->Base.Base.DiffuseIntensity = 0.5f; lc->Base.Atten.Constant = 0.5f; lc->Base.Atten.Exp = 0.5f; lc->Base.Atten.Linear = 0.5f; lc->Cutoff = 0.5f; lc->Base.Position = glm::vec3(1000, 1, 0);//4 1 0 lc->Direction = glm::vec3(0, -1, 0);// 5 0 0 light->SetVars(lSPOT, lc); } } animatedMech = new GameObject(100); animatedMechGC = new ComponentGraphics(); animatedMechGC->loadModel("models/Test_Animation_DAE.dae"); Component* c = animatedMechGC; animatedMech->AddComponent(GRAPHICS, c); animatedMech->pos = glm::vec3(0, 0, 0); animatedMech->scale = glm::vec3(1, 1, 1); //END MODEL INITS camInterp.points.push_back(glm::vec3(1025, 1, 0)); camInterp.points.push_back(glm::vec3(1000, 1, 25)); camInterp.points.push_back(glm::vec3(975, 1, 0)); camInterp.points.push_back(glm::vec3(1000, 1, -25)); camInterp.points.push_back(glm::vec3(1025, 1, 0)); camInterp.state = SLERP; camInterp.buildCurve(); TextRendering::getInstance().initText2D("MekFont.bmp"); fontColour = glm::normalize(fontColour); wglSwapIntervalEXT(1); // run while the window is open double lastTime = glfwGetTime(); while(!glfwWindowShouldClose(gWindow)){ // process pending events glfwPollEvents(); // update the scene based on the time elapsed since last update double thisTime = glfwGetTime(); Update((float)(thisTime - lastTime)); lastTime = thisTime; // draw one frame Render(); // check for errors GLenum error = glGetError(); if (error != GL_NO_ERROR) { std::cerr << "OpenGL Error " << error << " - " << glewGetErrorString(error) << std::endl; } //exit program if escape key is pressed if(glfwGetKey(gWindow, GLFW_KEY_ESCAPE)) glfwSetWindowShouldClose(gWindow, GL_TRUE); } // clean up and exit glfwTerminate(); }
//OpenGL Initialization Logic void glInit() { glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_POLYGON_OFFSET_LINE); glPolygonOffset(-1.f, -1.0f); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glm::vec3 coneDir = {0.f, -1.f, -1.f}; glm::vec4 lightPos = {0.f, 30.f, 30.f, 1.f}; glm::mat4 scaleBiasMat = {{0.5f, 0.f, 0.f, 0.f}, {0.f, 0.5f, 0.f, 0.f}, {0.f, 0.f, 0.5f, 0.f}, {0.5f, 0.5f, 0.5f, 1.f}}; //Shadow Map Creation gShadowProg = glCreateProgram(); gShadowVS = CreateShader(GL_VERTEX_SHADER, "shadow.vert"); gShadowFS = CreateShader(GL_FRAGMENT_SHADER, "shadow.frag"); glAttachShader(gShadowProg, gShadowVS); glAttachShader(gShadowProg, gShadowFS); glLinkProgram(gShadowProg); glUseProgram(gShadowProg); glGenFramebuffers(1, &gShadowFbo); glBindFramebuffer(GL_FRAMEBUFFER, gShadowFbo); glDrawBuffer(GL_NONE); glGenTextures(1, &gShadowTexture); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, gShadowTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, SHADOW_DEPTH_TEXTURE_SIZE, SHADOW_DEPTH_TEXTURE_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL); 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_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glActiveTexture(GL_TEXTURE0); glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, gShadowTexture, 0); if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) { std::cout << "Framebuffer Initialised" << std::endl; } glBindFramebuffer(GL_FRAMEBUFFER, 0); glm::mat4 shadowViewMat = glm::lookAt(glm::vec3(lightPos), glm::vec3(lightPos) + coneDir, glm::vec3(0, 1, 0)); glm::mat4 shadowProjMat = glm::frustum(-1.f, 1.f, -1.f, 1.f, 1.f, SHADOW_FRUSTRUM_DEPTH); gShadowModelMatLoc = glGetUniformLocation(gShadowProg, "uModelMat"); gShadowViewMatLoc = glGetUniformLocation(gShadowProg, "uViewMat"); glUniformMatrix4fv(gShadowViewMatLoc, 1, GL_FALSE, glm::value_ptr(shadowViewMat)); gShadowProjMatLoc = glGetUniformLocation(gShadowProg, "uProjMat"); glUniformMatrix4fv(gShadowProjMatLoc, 1, GL_FALSE, glm::value_ptr(shadowProjMat)); glGenVertexArrays(1, &gShadowVao); glBindVertexArray(gShadowVao); gShadowPosLoc = glGetAttribLocation(gShadowProg, "vPosition"); glEnableVertexAttribArray(gShadowPosLoc); //Program Creation gRenderProg = glCreateProgram(); gRenderVS = CreateShader(GL_VERTEX_SHADER, "shader.vert"); gRenderFS = CreateShader(GL_FRAGMENT_SHADER, "shader.frag"); glAttachShader(gRenderProg, gRenderVS); glAttachShader(gRenderProg, gRenderFS); glLinkProgram(gRenderProg); glUseProgram(gRenderProg); //Texture //Uniforms gModelMatLoc = glGetUniformLocation(gRenderProg, "uModelMat"); gModelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f)); glUniformMatrix4fv(gModelMatLoc, 1, GL_FALSE, glm::value_ptr(gModelMat)); gViewMatLoc = glGetUniformLocation(gRenderProg, "uViewMat"); glm::mat4 viewMat = glm::mat4(1.f); viewMat = glm::rotate(glm::mat4(1.f), 0.75f, glm::vec3(1.f, 0.f, 0.f)) * viewMat; viewMat = glm::translate(glm::mat4(1.f), glm::vec3(0.f, 0.f, -50.f)) * viewMat; glUniformMatrix4fv(gViewMatLoc, 1, GL_FALSE, glm::value_ptr(viewMat)); gProjMatLoc = glGetUniformLocation(gRenderProg, "uProjMat"); glm::mat4 projMat = glm::perspective(45.f, (float)gScreenWidth / (float)gScreenHeight, PROJ_NEAR, PROJ_FAR); glUniformMatrix4fv(gProjMatLoc, 1, GL_FALSE, glm::value_ptr(projMat)); gScaleBiasMatLoc = glGetUniformLocation(gRenderProg, "uScaleBiasMat"); glUniformMatrix4fv(gScaleBiasMatLoc, 1, GL_FALSE, glm::value_ptr(scaleBiasMat)); gShadowMatLoc = glGetUniformLocation(gRenderProg, "uShadowMat"); glm::mat4 shadowMat = shadowProjMat * shadowViewMat; glUniformMatrix4fv(gShadowMatLoc, 1, GL_FALSE, glm::value_ptr(shadowMat)); gTexUnitLoc = glGetUniformLocation(gRenderProg, "uTexUnit"); glUniform1i(gTexUnitLoc, 0); gIsTexturedLoc = glGetUniformLocation(gRenderProg, "uIsTextured"); glUniform1i(gIsTexturedLoc, 1); gColorLoc = glGetUniformLocation(gRenderProg, "uColor"); glm::vec4 color = {1.0f, 0.f, 0.f, 1.f}; glUniform4fv(gColorLoc, 1, glm::value_ptr(color)); gAmbientLoc = glGetUniformLocation(gRenderProg, "uAmbient"); glm::vec3 ambVec = {0.3f, 0.3f, 0.3f}; glUniform3fv(gAmbientLoc, 1, glm::value_ptr(ambVec)); gDiffuseLoc = glGetUniformLocation(gRenderProg, "uDiffuse"); glm::vec3 difVec = {0.5f, 0.f, 0.f}; glUniform3fv(gDiffuseLoc, 1, glm::value_ptr(difVec)); gSpecularLoc = glGetUniformLocation(gRenderProg, "uSpecular"); glm::vec3 specVec = {1.f, 1.f, 1.f}; glUniform3fv(gSpecularLoc, 1, glm::value_ptr(specVec)); gShininessLoc = glGetUniformLocation(gRenderProg, "uShininess"); float shininess = 20.0f; glUniform1f(gShininessLoc, shininess); gLightPosLoc = glGetUniformLocation(gRenderProg, "uLightPos"); glUniform4fv(gLightPosLoc, 1, glm::value_ptr(lightPos)); gSpecStrengthLoc = glGetUniformLocation(gRenderProg, "uSpecStrength"); float strength = 3.f; glUniform1f(gSpecStrengthLoc, strength); gConstAttenuationLoc = glGetUniformLocation(gRenderProg, "uConstAttenuation"); float constAttenuation = 1.f; glUniform1f(gConstAttenuationLoc, constAttenuation); gLinearAttenuationLoc = glGetUniformLocation(gRenderProg, "uLinearAttenuation"); float linearAttenuation = 0.05f; glUniform1f(gLinearAttenuationLoc, linearAttenuation); gConeDirectionLoc = glGetUniformLocation(gRenderProg, "uConeDirection"); glUniform3fv(gConeDirectionLoc, 1, glm::value_ptr(coneDir)); gConeAngleLoc = glGetUniformLocation(gRenderProg, "uConeAngle"); float coneAngle = 0.8f; glUniform1f(gConeAngleLoc, coneAngle); gSpotExponentLoc = glGetUniformLocation(gRenderProg, "uSpotExponent"); float spotExponent = 1.0f; glUniform1f(gSpotExponentLoc, spotExponent); gAmbientSkyLoc = glGetUniformLocation(gRenderProg, "uAmbientSky"); glm::vec3 ambientSky = {0.3f, 0.3f, 0.3f}; glUniform3fv(gAmbientSkyLoc, 1, glm::value_ptr(ambientSky)); gAmbientGroundLoc = glGetUniformLocation(gRenderProg, "uAmbientGround"); glm::vec3 ambientGround = {0.1f, 0.1f, 0.1f}; glUniform3fv(gAmbientGroundLoc, 1, glm::value_ptr(ambientGround)); gDepthTextureLoc = glGetUniformLocation(gRenderProg, "uDepthTexture"); glUniform1i(gDepthTextureLoc, 2); //Vertex Array Object glGenVertexArrays(1, &gVao); glBindVertexArray(gVao); //Vertex Attribute Specification gPosLoc = glGetAttribLocation(gRenderProg, "vPosition"); glEnableVertexAttribArray(gPosLoc); gTexCoordLoc = glGetAttribLocation(gRenderProg, "vTexCoord"); glEnableVertexAttribArray(gTexCoordLoc); gNormLoc = glGetAttribLocation(gRenderProg, "vNormal"); glEnableVertexAttribArray(gNormLoc); //Floor gFloorObj.modelMat = glm::mat4(1.f); GLuint floorBuffers[3]; glGenBuffers(3, &floorBuffers[0]); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[0]); glm::vec4 floorPosData[] = {{-60.f, 0.f, -30.f, 1.f}, {-60, 0.f, 30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {60.f, 0.f, -30.f, 1.f}, {-60.f, 0.f, 30.f, 1.f}, {60.f, 0.f, 30.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 4 * 6 * sizeof(float), &floorPosData[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[1]); glm::vec2 floorTexCoordData[] = {{0.f, 0.f}, {0.f, 1.f}, {1.f, 0.f}, {1.f, 0.f}, {0.f, 1.f}, {1.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 2 * 6 * sizeof(float), &floorTexCoordData[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, floorBuffers[2]); glm::vec3 floorNormData[] = {{0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}, {0.f, 1.f, 0.f}}; glBufferData(GL_ARRAY_BUFFER, 3 * 6 * sizeof(float), &floorNormData[0], GL_STATIC_DRAW); gFloorObj.glPosBuf = floorBuffers[0]; gFloorObj.glTexCoordBuf = floorBuffers[1]; gFloorObj.glNormBuf = floorBuffers[2]; gFloorObj.vertCount = 6; gFloorObj.ambientColor = {0.3f, 0.3f, 0.3f}; gFloorObj.diffuseColor = {0.5f, 0.5f, 0.5f}; gFloorObj.specularColor = {1.f, 1.f, 1.f}; gFloorObj.shininess = 20.f; gFloorObj.specStrength = 0.f; gFloorObj.isTextured = false; gFloorObj.objColor = {0.5f, 0.5f, 0.5f, 1.f}; //Teapot gTeapotObj.modelMat = glm::rotate(glm::mat4(1.f), -1.57f, glm::vec3(1.f, 0.f, 0.f)); GLuint TeapotBuffers[3]; glGenBuffers(3, &TeapotBuffers[0]); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[0]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 4 * sizeof(float), &teapot.m_Info.v[0], GL_STREAM_DRAW); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[1]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 2 * sizeof(float), &teapot.m_Info.vt[0], GL_STREAM_DRAW); glBindBuffer(GL_ARRAY_BUFFER, TeapotBuffers[2]); glBufferData(GL_ARRAY_BUFFER, teapot.m_Info.vertCount * 3 * sizeof(float), &teapot.m_Info.vn[0], GL_STREAM_DRAW); gTeapotObj.glPosBuf = TeapotBuffers[0]; gTeapotObj.glTexCoordBuf = TeapotBuffers[1]; gTeapotObj.glNormBuf = TeapotBuffers[2]; gTeapotObj.vertCount = teapot.m_Info.vertCount; gTeapotObj.ambientColor = {0.3f, 0.3f, 0.3f}; gTeapotObj.diffuseColor = {0.8f, 0.f, 0.f}; gTeapotObj.specularColor = {1.f, 1.f, 1.f}; gTeapotObj.shininess = 20.f; gTeapotObj.specStrength = 5.f; gTeapotObj.isTextured = false; GLuint TeapotTexture; int imgWidth, imgHeight, imgComp; gTexImage = stbi_load("texture.jpg", &imgWidth, &imgHeight, &imgComp, STBI_rgb); glGenTextures(1, &TeapotTexture); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, TeapotTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, gTexImage); glActiveTexture(GL_TEXTURE0); gTeapotObj.glTexture = TeapotTexture; gTeapotObj.glTexUnit = 1; gSceneGraph.push_back(gTeapotObj); gSceneGraph.push_back(gFloorObj); gTextureProg = glCreateProgram(); gTextureVS = CreateShader(GL_VERTEX_SHADER, "texture.vert"); gTextureFS = CreateShader(GL_FRAGMENT_SHADER, "texture.frag"); glAttachShader(gTextureProg, gTextureVS); glAttachShader(gTextureProg, gTextureFS); glLinkProgram(gTextureProg); glUseProgram(gTextureProg); gTextureTexLoc = glGetUniformLocation(gTextureProg, "uTexture"); glUniform1i(gTextureTexLoc, 2); glGenBuffers(1, &gTexturePosBuf); glBindBuffer(GL_ARRAY_BUFFER, gTexturePosBuf); glm::vec4 texturePosData[] = {{-0.5f, 0.5f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {0.5f, 0.5f, 0.f, 1.f}, {0.5f, 0.5f, 0.f, 1.f}, {-0.5f, -0.5f, 0.f, 1.f}, {0.5f, -0.5f, 0.f, 1.f}}; glBufferData(GL_ARRAY_BUFFER, 6 * 4 * sizeof(float), &texturePosData[0], GL_STATIC_DRAW); glGenBuffers(1, &gTextureTexCoordBuf); glBindBuffer(GL_ARRAY_BUFFER, gTextureTexCoordBuf); glm::vec2 textureTexCoordData[] = {{0.f, 1.f}, {0.f, 0.f}, {1.f, 1.f}, {1.f, 1.f}, {0.f, 0.f}, {1.f, 0.f}}; glBufferData(GL_ARRAY_BUFFER, 6 * 2 * sizeof(float), &textureTexCoordData[0], GL_STATIC_DRAW); glGenVertexArrays(1, &gTextureVao); glBindVertexArray(gTextureVao); gTexturePosLoc = glGetAttribLocation(gTextureProg, "vPosition"); glEnableVertexAttribArray(gTexturePosLoc); glBindBuffer(GL_ARRAY_BUFFER, gTexturePosBuf); glVertexAttribPointer(gTexturePosLoc, 4, GL_FLOAT, GL_FALSE, 0, NULL); gTextureTexCoordLoc = glGetAttribLocation(gTextureProg, "vTexCoord"); glEnableVertexAttribArray(gTextureTexCoordLoc); glBindBuffer(GL_ARRAY_BUFFER, gTextureTexCoordBuf); glVertexAttribPointer(gTextureTexCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, NULL); }
int main () { GLFWwindow* window; const GLubyte* renderer; const GLubyte* version; GLfloat points[] = { 0.0f, 0.5f, 0.0f, 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f }; GLuint vbo; GLuint vao; const char* vertex_shader = "#version 400\n" "in vec3 vp;" "void main () {" " gl_Position = vec4 (vp, 1.0);" "}"; const char* fragment_shader = "#version 400\n" "out vec4 frag_colour;" "void main () {" " frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);" "}"; GLuint shader_programme, vs, fs; assert (restart_gl_log ()); // start GL context and O/S window using the GLFW helper library gl_log ("starting GLFW\n%s\n", glfwGetVersionString ()); // register the error call-back function that we wrote, above glfwSetErrorCallback (glfw_error_callback); if (!glfwInit ()) { fprintf (stderr, "ERROR: could not start GLFW3\n"); return 1; } // uncomment these lines if on Apple OS X /*glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); */ /* we can run a full-screen window here */ /*GLFWmonitor* mon = glfwGetPrimaryMonitor (); const GLFWvidmode* vmode = glfwGetVideoMode (mon); GLFWwindow* window = glfwCreateWindow ( vmode->width, vmode->height, "Extended GL Init", mon, NULL );*/ window = glfwCreateWindow ( g_gl_width, g_gl_height, "Extended Init.", NULL, NULL ); if (!window) { fprintf (stderr, "ERROR: could not open window with GLFW3\n"); glfwTerminate(); return 1; } glfwSetWindowSizeCallback (window, glfw_window_size_callback); glfwMakeContextCurrent (window); glfwWindowHint (GLFW_SAMPLES, 4); // start GLEW extension handler 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); gl_log ("renderer: %s\nversion: %s\n", renderer, version); log_gl_params (); // tell GL to only draw onto a pixel if the shape is closer to the viewer glEnable (GL_DEPTH_TEST); // enable depth-testing glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer" glGenBuffers (1, &vbo); glBindBuffer (GL_ARRAY_BUFFER, vbo); glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (GLfloat), points, GL_STATIC_DRAW); glGenVertexArrays (1, &vao); glBindVertexArray (vao); glEnableVertexAttribArray (0); glBindBuffer (GL_ARRAY_BUFFER, vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); vs = glCreateShader (GL_VERTEX_SHADER); glShaderSource (vs, 1, &vertex_shader, NULL); glCompileShader (vs); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (fs, 1, &fragment_shader, NULL); glCompileShader (fs); shader_programme = glCreateProgram (); glAttachShader (shader_programme, fs); glAttachShader (shader_programme, vs); glLinkProgram (shader_programme); while (!glfwWindowShouldClose (window)) { _update_fps_counter (window); // wipe the drawing surface clear glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport (0, 0, g_gl_width, g_gl_height); glUseProgram (shader_programme); glBindVertexArray (vao); // draw points 0-3 from the currently bound VAO with current in-use shader glDrawArrays (GL_TRIANGLES, 0, 3); // update other events like input handling glfwPollEvents (); if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_ESCAPE)) { glfwSetWindowShouldClose (window, 1); } // put the stuff we've been drawing onto the display glfwSwapBuffers (window); } // close GL context and any other GLFW resources glfwTerminate(); return 0; }
int main(int ac, char **av) { fprintf(stderr, "Ray V1.0\nWritten by David Bucciarelli ([email protected])\n"); /* if(!SetPriorityClass(GetCurrentProcess(),REALTIME_PRIORITY_CLASS)) { fprintf(stderr,"Error setting the process class.\n"); return 0; } if(!SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_TIME_CRITICAL)) { fprintf(stderr,"Error setting the process priority.\n"); return 0; } */ glutInitWindowPosition(0, 0); glutInitWindowSize(WIDTH, HEIGHT); glutInit(&ac, av); glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); if (!(win = glutCreateWindow("Ray"))) { fprintf(stderr, "Error, couldn't open window\n"); return -1; } reshape(WIDTH, HEIGHT); glShadeModel(GL_FLAT); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_FOG); glFogi(GL_FOG_MODE, GL_EXP2); glFogfv(GL_FOG_COLOR, fogcolor); glFogf(GL_FOG_DENSITY, 0.01); #ifdef FX glHint(GL_FOG_HINT, GL_NICEST); #endif calcposobs(); initspherepos(); inittextures(); initdlists(); glClearColor(fogcolor[0], fogcolor[1], fogcolor[2], fogcolor[3]); glutReshapeFunc(reshape); glutDisplayFunc(draw); glutKeyboardFunc(key); glutSpecialFunc(special); glutIdleFunc(draw); glutMainLoop(); return 0; }
int video_mode(int f, int w, int h) { int stereo = config_get_d(CONFIG_STEREO) ? 1 : 0; int stencil = config_get_d(CONFIG_REFLECTION) ? 1 : 0; int buffers = config_get_d(CONFIG_MULTISAMPLE) ? 1 : 0; int samples = config_get_d(CONFIG_MULTISAMPLE); int vsync = config_get_d(CONFIG_VSYNC) ? 1 : 0; int hmd = config_get_d(CONFIG_HMD) ? 1 : 0; hmd_free(); SDL_GL_SetAttribute(SDL_GL_STEREO, stereo); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, stencil); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, buffers); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples); SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, vsync); /* Require 16-bit double buffer with 16-bit depth buffer. */ SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); /* Try to set the currently specified mode. */ if (SDL_SetVideoMode(w, h, 0, SDL_OPENGL | (f ? SDL_FULLSCREEN : 0))) { config_set_d(CONFIG_FULLSCREEN, f); config_set_d(CONFIG_WIDTH, w); config_set_d(CONFIG_HEIGHT, h); if (!glext_init()) return 0; glViewport(0, 0, w, h); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_TEXTURE_2D); glEnable(GL_LIGHTING); glEnable(GL_BLEND); #if !ENABLE_OPENGLES glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); #endif glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDepthFunc(GL_LEQUAL); /* If GL supports multisample, and SDL got a multisample buffer... */ if (glext_check("ARB_multisample")) { SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &buffers); if (buffers) glEnable(GL_MULTISAMPLE); } /* Attempt manual swap control if SDL's is broken. */ if (vsync && SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL, &vsync) == -1) sync_init(); /* Set up HMD display if requested. */ if (hmd) hmd_init(); /* Initialize screen snapshotting. */ snapshot_init(); video_show_cursor(); return 1; } /* If the mode failed, try it without stereo. */ else if (stereo) { config_set_d(CONFIG_STEREO, 0); return video_mode(f, w, h); } /* If the mode failed, try decreasing the level of multisampling. */ else if (buffers) { config_set_d(CONFIG_MULTISAMPLE, samples / 2); return video_mode(f, w, h); } /* If that mode failed, try it without reflections. */ else if (stencil) { config_set_d(CONFIG_REFLECTION, 0); return video_mode(f, w, h); } /* If THAT mode failed, punt. */ return 0; }
void GLWidget::draw() { QPainter p(this); // used for text overlay // save the GL state set for QPainter p.beginNativePainting(); saveGLState(); // render the 'bubbles.svg' file into our pbuffer QPainter pbuffer_painter(pbuffer); svg_renderer->render(&pbuffer_painter); pbuffer_painter.end(); glFlush(); if (!hasDynamicTextureUpdate) pbuffer->updateDynamicTexture(dynamicTexture); makeCurrent(); // draw into the GL widget glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-1, 1, -1, 1, 10, 100); glTranslatef(0.0f, 0.0f, -15.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glViewport(0, 0, width() * devicePixelRatio(), height() * devicePixelRatio()); glBindTexture(GL_TEXTURE_2D, dynamicTexture); glEnable(GL_TEXTURE_2D); glEnable(GL_MULTISAMPLE); glEnable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // draw background glPushMatrix(); glScalef(1.7f, 1.7f, 1.7f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glCallList(tile_list); glPopMatrix(); const int w = logo.width(); const int h = logo.height(); glRotatef(rot_x, 1.0f, 0.0f, 0.0f); glRotatef(rot_y, 0.0f, 1.0f, 0.0f); glRotatef(rot_z, 0.0f, 0.0f, 1.0f); glScalef(scale/w, scale/w, scale/w); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); // draw the Qt icon glTranslatef(-w+1, -h+1, 0.0f); for (int y=h-1; y>=0; --y) { uint *p = (uint*) logo.scanLine(y); uint *end = p + w; int x = 0; while (p < end) { glColor4ub(qRed(*p), qGreen(*p), qBlue(*p), uchar(qAlpha(*p)*.9)); glTranslatef(0.0f, 0.0f, wave[y*w+x]); if (qAlpha(*p) > 128) glCallList(tile_list); glTranslatef(0.0f, 0.0f, -wave[y*w+x]); glTranslatef(2.0f, 0.0f, 0.0f); ++x; ++p; } glTranslatef(-w*2.0f, 2.0f, 0.0f); } // restore the GL state that QPainter expects restoreGLState(); p.endNativePainting(); // draw the overlayed text using QPainter p.setPen(QColor(197, 197, 197, 157)); p.setBrush(QColor(197, 197, 197, 127)); p.drawRect(QRect(0, 0, width(), 50)); p.setPen(Qt::black); p.setBrush(Qt::NoBrush); const QString str1(tr("A simple OpenGL pbuffer example.")); const QString str2(tr("Use the mouse wheel to zoom, press buttons and move mouse to rotate, double-click to flip.")); QFontMetrics fm(p.font()); p.drawText(width()/2 - fm.width(str1)/2, 20, str1); p.drawText(width()/2 - fm.width(str2)/2, 20 + fm.lineSpacing(), str2); }
void render() { const SDL_VideoInfo *vidinfo; int x,y,w,h; int i; char buf[1000]; Uint32 vidfr = (metafr-1); Uint32 vidfrmod = vidfr%maxframes; Uint32 render_start = SDL_GetTicks(); static Uint32 total_start = 0; Uint32 tmp; if( metafr==0 || vidfr<=drawnfr ) //==0 prevent never-draw bug return; if( soon==1 ) setvideo(soon_w,soon_h,soon_full,0); if( soon>0 ) soon--; vidinfo = SDL_GetVideoInfo(); w = v_w = vidinfo->current_w; h = v_h = vidinfo->current_h; pad_left = 0; pad_top = 0; if( v_center ) { pad_left = (w - NATIVEW*scale)/2; pad_top = (h - NATIVEH*scale)/2; } glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef(1.0f/256.0f, 1.0f/256.0f, 1); glColor4f(1.0f,1.0f,1.0f,1.0f); glEnable(GL_TEXTURE_2D); if( v_usealpha ) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); else glBlendFunc(GL_ONE, GL_ZERO); glEnable(GL_BLEND); glAlphaFunc(GL_GREATER,0.01); glEnable(GL_ALPHA_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); // viewport and matrixes for game objects glViewport(pad_left,h-NATIVEH*scale-pad_top,NATIVEW*scale,NATIVEH*scale); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0,NATIVEW,NATIVEH,0,-NATIVEH*3-1,NATIVEH*3+1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); int camx = NATIVEW/2-(int)v_camx, camy = NATIVEH/2-(int)v_camy; glTranslatef(camx,camy,0); SJGL_SetTex( (GLuint)-1 ); //forget previous texture name mod_predraw(vidfr); //display objects for(i=0;i<maxobjs;i++) { OBJ_t *o = fr[vidfrmod].objs+i; if( o->flags&OBJF_VIS ) mod_draw(i,o); // have the mod draw the actual thing } mod_postdraw(vidfr); glDisable(GL_DEPTH_TEST); //display hulls and object numbers if( v_drawhulls ) { glBindTexture( GL_TEXTURE_2D, 0 ); glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); if( mycontext ) { CONTEXT_t *co = fr[vidfrmod].objs[mycontext].data; int x,y,z; for( z=0; z<co->z; z++ ) for( y=0; y<co->y; y++ ) for( x=0; x<co->x; x++ ) { int pos = co->x*co->y*z + co->x*y + x; int flags; if( co->dmap[ pos ].flags & CBF_NULL ) flags = co->map[ pos ].flags; else flags = co->dmap[ pos ].flags; if( flags & CBF_SOLID ) { glColor4f(1,0,0,1); SJGL_Blit( &(SDL_Rect){0,0,16,16}, x*16, y*16, z ); SJGL_Blit( &(SDL_Rect){0,0,12,12}, x*16+2, y*16+2, z ); } else if( flags & CBF_PLAT ) { glColor4f(0,1,0,1); SJGL_Blit( &(SDL_Rect){0,0,16, 2}, x*16, y*16, z ); } } } glColor4f(1,1,1,1); for(i=0;i<maxobjs;i++) { OBJ_t *o = fr[vidfrmod].objs+i; V *pos = flex(o,OBJF_POS); V *hull = flex(o,OBJF_HULL); if( pos && hull ) { SDL_Rect rect = (SDL_Rect){0, 0, hull[1].x-hull[0].x, hull[1].y-hull[0].y}; SJGL_Blit( &rect, pos->x+hull[0].x, pos->y+hull[0].y, 0 ); } } glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); for(i=0;i<maxobjs;i++) { OBJ_t *o = fr[vidfrmod].objs+i; V *pos = flex(o,OBJF_POS); if( pos ) { sprintf(buf,"%d",i); SJF_DrawText(pos->x, pos->y, buf); } } } // viewport and matrixes for HUD glViewport(0,0,w,h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0,w,h,0,-1,1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //paint black over the border areas, subtractively with v_oob { int outerl = 0; int innerl = pad_left; int outert = 0; int innert = pad_top; int outerr = w; int innerr = pad_left + NATIVEW*scale; int outerb = h; int innerb = pad_top + NATIVEH*scale; glDisable(GL_TEXTURE_2D); glPushAttrib(GL_COLOR_BUFFER_BIT); if( v_oob ) { glColor4f(0.02,0.02,0.02,0.02); glBlendFunc(GL_ONE,GL_ONE); if( GLEW_EXT_blend_equation_separate ) glBlendEquation(GL_FUNC_REVERSE_SUBTRACT); } else glColor4f(0,0,0,1.0f); glBegin(GL_QUADS); glVertex2i(outerl,outert); glVertex2i(outerr,outert); glVertex2i(outerr,innert); glVertex2i(outerl,innert); //top glVertex2i(outerl,innerb); glVertex2i(outerr,innerb); glVertex2i(outerr,outerb); glVertex2i(outerl,outerb); //bottom glVertex2i(outerl,innert); glVertex2i(innerl,innert); glVertex2i(innerl,innerb); glVertex2i(outerl,innerb); //left glVertex2i(innerr,innert); glVertex2i(outerr,innert); glVertex2i(outerr,innerb); glVertex2i(innerr,innerb); //right glEnd(); glPopAttrib(); glEnable(GL_TEXTURE_2D); glColor4f(1.0f,1.0f,1.0f,1.0f); } SJGL_SetTex( (GLuint)-1 ); //forget previous texture name mod_outerdraw(vidfr,w,h); //display console if(console_open) { int conh = h/2 - 40; if(conh<40) conh = 40; glColor4f(0.15,0.15,0.15,0.85); glDisable(GL_TEXTURE_2D); glBegin(GL_QUADS); glVertex2i(0, 0); glVertex2i(w, 0); glVertex2i(w,conh); glVertex2i(0,conh); glEnd(); glEnable(GL_TEXTURE_2D); glColor4f(1.0f,1.0f,1.0f,1.0f); x = 10; y = conh-20; if((ticks/200)%2) SJF_DrawChar(x+SJF_TextExtents(SJC.buf[0]), y, '_'); for(i=0;y>0;i++) { if(SJC.buf[i]) SJF_DrawText(x,y,SJC.buf[i]); y -= 10; } if( SJC.buf[0] && SJC.buf[0][0] ) { char s[10]; sprintf(s,"%d",SJC.buf[0][strlen(SJC.buf[0])-1]); SJF_DrawText(w-20,conh-20,s); } } //display stats total_time += (tmp = SDL_GetTicks()) - total_start; render_time += tmp - render_start; total_start = tmp; Uint32 unaccounted_time = total_time - (idle_time + render_time + adv_move_time + adv_collide_time + adv_game_time); if( v_showstats ) { Uint32 denom = vidfrmod+1; sprintf(buf,"idle_time %4d" , idle_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),10,buf); sprintf(buf,"render_time %4d" , render_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),20,buf); sprintf(buf,"adv_move_time %4d" , adv_move_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),30,buf); sprintf(buf,"adv_collide_time %4d",adv_collide_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),40,buf); sprintf(buf,"adv_game_time %4d" , adv_game_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),50,buf); sprintf(buf,"unaccounted_time %4d",unaccounted_time/denom); SJF_DrawText(w-20-SJF_TextExtents(buf),60,buf); sprintf(buf,"adv_frames %2.2f" ,(float)adv_frames/(float)denom); SJF_DrawText(w-20-SJF_TextExtents(buf),70,buf); sprintf(buf,"fr: idx=%d meta=%d vid=%d hot=%d",metafr%maxframes,metafr,vidfr,hotfr); SJF_DrawText(w-20-SJF_TextExtents(buf),80,buf); } SDL_GL_SwapBuffers(); setdrawnfr(vidfr); if( (int)vidfrmod==maxframes-1 ) { // reset time stats total_time = 0; idle_time = 0; render_time = 0; adv_move_time = 0; adv_collide_time = 0; adv_game_time = 0; adv_frames = 0; } }
static bool test_with_format(GLenum internal_format, const char *name) { GLuint rb, fb; GLenum status; bool pass = true; /* Storage for the values read. The largest type is * GLuint-sized, so this will be big enough for all types. */ GLuint values[BUF_WIDTH * BUF_HEIGHT]; int i; printf("testing %s:\n", name); glGenFramebuffersEXT(1, &fb); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb); assert(glGetError() == 0); glGenRenderbuffersEXT(1, &rb); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rb); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internal_format, BUF_WIDTH, BUF_HEIGHT); glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rb); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT); if (status != GL_FRAMEBUFFER_COMPLETE_EXT) { fprintf(stderr, "framebuffer incomplete\n"); piglit_report_subtest_result(PIGLIT_SKIP, name); goto done; } glGetIntegerv(GL_DEPTH_BITS, &depth_bits); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_ALWAYS); glViewport(0, 0, BUF_WIDTH, BUF_HEIGHT); piglit_ortho_projection(BUF_WIDTH, BUF_HEIGHT, false); piglit_draw_rect_z(1.0, 0, 0, w, BUF_HEIGHT); piglit_draw_rect_z(0.0, w, 0, w * 2, BUF_HEIGHT); piglit_draw_rect_z(-1.0, w * 2, 0, w * 3, BUF_HEIGHT); glPixelStorei(GL_PACK_ALIGNMENT, 1); for (i = 0; i < ARRAY_SIZE(read_formats); i++) { int x, y; bool format_passed = true; glReadPixels(0, 0, BUF_WIDTH, BUF_HEIGHT, GL_DEPTH_COMPONENT, read_formats[i].token, values); for (y = 0; y < BUF_HEIGHT; y++) { for (x = 0; x < BUF_WIDTH; x++) { if (!read_formats[i].test(x, y, values)) { format_passed = false; break; } } if (x != BUF_WIDTH) break; } piglit_report_subtest_result((format_passed ? PIGLIT_PASS : PIGLIT_FAIL), "%s/%s", name, read_formats[i].name); pass = format_passed && pass; } done: glDeleteFramebuffersEXT(1, &fb); glDeleteRenderbuffersEXT(1, &rb); return pass; }
bool COLLADA_Viewer::onInit(int argc, char **ppArgv) { FWGLApplication::onInit(argc, ppArgv); glClearColor(0.3f,0.3f,0.7f, 0.0f); glClearDepthf(1.0f); glEnable(GL_DEPTH_TEST); FWDebugFont::setColor(1.f, 1.f, 1.f, 1.f); InitFS(); Browser.Init(); psglLoadShaderLibrary("/app_home/shaders.bin"); // Initialize the renderer _CrtRender.Init(); _CrtRender.SetUsingVBOs(CrtTrue); _CrtRender.SetShowHiearchy(CrtTrue); glEnable(GL_TEXTURE_2D); glShadeModel(GL_SMOOTH); glClearColor(0.0f, 0.0f, 1.0f, 0.5f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); cgRTCgcInit(); ParseDir("/app_home/"); // Load the target file Browser.onUpdate(); if (argc > 0) { char path_name[1024]; mCurrentFile = ppArgv[0]; sprintf(path_name, "%s%s", "/app_home/", ppArgv[0]); printf(path_name); load_ok = _CrtRender.Load(path_name, NULL); if ( !load_ok ) return false; } else if (Browser.GetSize() > 0) { mCurrentFile = Browser.GetThumbnail(0)->GetDocument(); load_ok = _CrtRender.Load(mCurrentFile, NULL); if ( !load_ok ) return false; } // Get the gamepad so we can read it later mpPad = FWInput::getDevice(FWInput::DeviceType_Pad,0); if(mpPad==NULL) { printf("Error, couldn't get a pad\n"); exit(0); } mpInputX0 = mpPad->bindFilter(); mpInputX0->setChannel(FWInput::Channel_XAxis_0); mpInputX0->setGain( 1.0f ); mpInputX0->setDeadzone( 0.3f ); mpInputY0 = mpPad->bindFilter(); mpInputY0->setChannel(FWInput::Channel_YAxis_0); mpInputY0->setGain( 1.0f ); mpInputY0->setDeadzone( 0.3f ); mpInputX1 = mpPad->bindFilter(); mpInputX1->setChannel(FWInput::Channel_XAxis_1); mpInputX1->setGain( 1.0f ); mpInputX1->setDeadzone( 0.3f ); mpInputY1 = mpPad->bindFilter(); mpInputY1->setChannel(FWInput::Channel_YAxis_1); mpInputY1->setGain( 1.0f ); mpInputY1->setDeadzone( 0.3f ); // initialize debug font library, then open console. int ret; CellDbgFontConfig cfg; memset(&cfg, 0, sizeof(CellDbgFontConfig)); cfg.bufSize = 512; cfg.screenWidth = mDispInfo.mWidth; cfg.screenHeight = mDispInfo.mHeight; ret = cellDbgFontInit(&cfg); if (ret != CELL_OK) { printf("cellDbgFontInit() failed %x\n", ret); return true; } CellDbgFontConsoleConfig ccfg; memset(&ccfg, 0, sizeof(CellDbgFontConsoleConfig)); ccfg.posLeft = 0.1f; ccfg.posTop = 0.6f; ccfg.cnsWidth = 16; ccfg.cnsHeight = 4; ccfg.scale = 1.5f; ccfg.color = 0xffffffff; mDbgFontID = cellDbgFontConsoleOpen(&ccfg); if (mDbgFontID < 0) { printf("cellDbgFontConsoleOpen() failed %x\n", mDbgFontID); return true; } return true; }
static void Init(ModeInfo *mi) { atlantisstruct *ap = &atlantis[MI_SCREEN(mi)]; static const float ambient[] = {0.1, 0.1, 0.1, 1.0}; static const float diffuse[] = {1.0, 1.0, 1.0, 1.0}; static const float position[] = {0.0, 1.0, 0.0, 0.0}; static const float mat_shininess[] = {90.0}; static const float mat_specular[] = {0.8, 0.8, 0.8, 1.0}; static const float mat_diffuse[] = {0.46, 0.66, 0.795, 1.0}; static const float mat_ambient[] = {0.0, 0.1, 0.2, 1.0}; static const float lmodel_ambient[] = {0.4, 0.4, 0.4, 1.0}; static const float lmodel_localviewer[] = {0.0}; float fblue = 0.0, fgreen; glFrontFace(GL_CCW); if (ap->wire) { glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glDisable(GL_NORMALIZE); } else { glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_NORMALIZE); glShadeModel(GL_SMOOTH); glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); glLightfv(GL_LIGHT0, GL_POSITION, position); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_localviewer); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient); } if (ap->wire || !do_texture) { glDisable(GL_TEXTURE_2D); } else { GLfloat s_plane[] = { 1, 0, 0, 0 }; GLfloat t_plane[] = { 0, 0, 1, 0 }; GLfloat scale = 0.0005; if (!ap->texture) parse_image_data (mi); clear_gl_error(); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ap->texture->width, ap->texture->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, ap->texture->data); check_gl_error("texture"); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); glTexGenfv(GL_S, GL_EYE_PLANE, s_plane); glTexGenfv(GL_T, GL_EYE_PLANE, t_plane); # ifndef HAVE_JWZGLES glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); # endif glEnable(GL_TEXTURE_2D); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef(scale, scale, 1); glMatrixMode(GL_MODELVIEW); } InitFishs(ap); /* Add a little randomness */ fblue = ((float) (NRAND(30)) / 100.0) + 0.70; fgreen = fblue * 0.56; glClearColor(0.0, fgreen, fblue, 1.0); }
void myinit() { // GLfloat light_ambient[] = { btScalar(0.2), btScalar(0.2), btScalar(0.2), btScalar(1.0) }; GLfloat light_ambient[] = { btScalar(1.0), btScalar(1.2), btScalar(0.2), btScalar(1.0) }; GLfloat light_diffuse[] = { btScalar(1.0), btScalar(1.0), btScalar(1.0), btScalar(1.0) }; GLfloat light_specular[] = { btScalar(1.0), btScalar(1.0), btScalar(1.0), btScalar(1.0 )}; /* light_position is NOT default value */ GLfloat light_position0[] = { btScalar(1000.0), btScalar(1000.0), btScalar(1000.0), btScalar(0.0 )}; GLfloat light_position1[] = { btScalar(-1.0), btScalar(-10.0), btScalar(-1.0), btScalar(0.0) }; glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position0); glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT1, GL_POSITION, light_position1); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); // glShadeModel(GL_FLAT);//GL_SMOOTH); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glClearColor(float(0.7),float(0.7),float(0.7),float(0)); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); static bool m_textureenabled = true; static bool m_textureinitialized = false; if(m_textureenabled) { if(!m_textureinitialized) { glActiveTexture(GL_TEXTURE0); GLubyte* image=new GLubyte[256*256*3]; for(int y=0;y<256;++y) { const int t=y>>5; GLubyte* pi=image+y*256*3; for(int x=0;x<256;++x) { const int s=x>>5; const GLubyte b=180; GLubyte c=b+((s+t&1)&1)*(255-b); pi[0]=255; pi[1]=c; pi[2]=c; pi+=3; } } glGenTextures(1,(GLuint*)&m_texturehandle); glBindTexture(GL_TEXTURE_2D,m_texturehandle); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); gluBuild2DMipmaps(GL_TEXTURE_2D,3,256,256,GL_RGB,GL_UNSIGNED_BYTE,image); delete[] image; m_textureinitialized=true; } // glMatrixMode(GL_TEXTURE); // glLoadIdentity(); // glMatrixMode(GL_MODELVIEW); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,m_texturehandle); } else
int main(int argc, char **argv) { int i; if (argc > 1) { /* make sure at least 2 args, program and file */ strncpy(filename, argv[argc - 1], sizeof(filename)); /* get the last arg as the file always */ for (i = 0; i < argc; i++) { /* check for startup params */ if (strstr(argv[i], "-s")) stereo = 1; if (strstr(argv[i], "-f")) full_screen = 1; } } else { /* user only entered program name, help them */ printf("Usage: %s [-s] [-f] <obj filename>\n", argv[0]); exit(0); } glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(1024, 768); /* Window Size If We Start In Windowed Mode */ glutCreateWindow("Wavefront Obj File Viewer"); if (full_screen) glutFullScreen(); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); getMatrix(); glClearColor(0.0, 0.0, 0.0, 0.0); glClearAccum(0.0, 0.0, 0.0, 0.0); glutReshapeFunc(Reshape); glutMouseFunc(Mouse); glutMotionFunc(Motion); glutIdleFunc(NULL); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess); if (lighting) glEnable(GL_LIGHTING); if (lighting) glEnable(GL_LIGHT0); glDepthFunc(GL_LESS); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_TEXTURE_2D); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); if (!pmodel) { /* load up the model */ pmodel = glmReadOBJ(filename); if (!pmodel) { printf("\nUsage: objviewV2 <-s> <obj filename>\n"); exit(0); } glmUnitize(pmodel); glmVertexNormals(pmodel, 90.0, GL_TRUE); } glutMainLoop(); return 0; }
bool8 S9xOpenGLInit2 () { glXMakeCurrent (GUI.display, GUI.window, GUI.glcontext); glGetIntegerv (GL_MAX_TEXTURE_SIZE, &OpenGL.max_texture_size); if (OpenGL.max_texture_size >= 512) { OpenGL.texture_size = 512; OpenGL.num_textures = 2; } else { OpenGL.texture_size = OpenGL.max_texture_size; OpenGL.num_textures = 1; } Settings.OpenGLEnable = TRUE; const char *ext = (const char *) glGetString (GL_EXTENSIONS); if (ext && strstr (ext, "EXT_packed_pixels") != NULL) OpenGL.packed_pixels_extension_present = TRUE; const char *version = (const char *) glGetString (GL_VERSION); if (version && strlen (version) < 100) { char ver [100]; strcpy (ver, version); // Strip dots from the version string char *ptr; while (ptr = strchr (ver, '.')) memmove (ptr, ptr + 1, strlen (ptr + 1) + 1); // Pad the string with zeros to 4 digits while (strlen (ver) < 4) strcat (ver, "0"); OpenGL.version = atoi (ver); } else OpenGL.version = 1100; #ifndef GL_UNSIGNED_SHORT_5_5_5_1_EXT #define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 #endif if (OpenGL.version >= 1200) { OpenGL.internal_format = GL_RGB5_A1; OpenGL.format = GL_RGBA; OpenGL.type = GL_UNSIGNED_SHORT_5_5_5_1_EXT; S9xSetRenderPixelFormat (RGB5551); } else if (OpenGL.packed_pixels_extension_present) { OpenGL.internal_format = GL_RGB5_A1; OpenGL.format = GL_RGBA; OpenGL.type = GL_UNSIGNED_SHORT_5_5_5_1_EXT; S9xSetRenderPixelFormat (RGB5551); } else { OpenGL.internal_format = GL_RGB; OpenGL.format = GL_RGB; OpenGL.type = GL_UNSIGNED_BYTE; } glGenTextures (OpenGL.num_textures, OpenGL.textures); if (OpenGL.num_textures == 2) { glBindTexture (GL_TEXTURE_2D, OpenGL.textures [1]); glTexImage2D (GL_TEXTURE_2D, 0, OpenGL.internal_format, 256, 256, 0, OpenGL.format, OpenGL.type, NULL); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } glBindTexture (GL_TEXTURE_2D, OpenGL.textures [0]); glTexImage2D (GL_TEXTURE_2D, 0, OpenGL.internal_format, OpenGL.texture_size, OpenGL.texture_size, 0, OpenGL.format, OpenGL.type, NULL); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glPolygonMode (GL_FRONT, GL_FILL); glEnable (GL_CULL_FACE); glCullFace (GL_BACK); glEnable (GL_DITHER); glEnable (GL_LIGHTING); glEnable (GL_LIGHT0); glEnable (GL_POINT_SMOOTH); glHint (GL_POINT_SMOOTH_HINT, GL_NICEST); glEnable (GL_TEXTURE_2D); glShadeModel (GL_SMOOTH); glEnable (GL_POLYGON_SMOOTH); glClearColor (0.0f, 0.0f, 0.0f, 0.0f); glClearDepth (1.0f); glDisable (GL_DEPTH_TEST); glDepthFunc (GL_LESS); glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glClearColor (0, 0, 0, 1); glClear (GL_COLOR_BUFFER_BIT); glFlush (); return (TRUE); }
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; // Calculate frame-to-frame delta time dt = (float) (t - t_old); t_old = t; glClearColor(0.1f, 0.1f, 0.1f, 1.f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(65.0, aspect_ratio, 1.0, 60.0); // 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); }
// Initialize our rendering device int GLDriver::initialize(IWindow* pWindow) { Assert(pWindow != NULL); Trace("Initializing OpenGL"); glClearColor(0.0f, 0.0f, 0.0f, 0.5f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glClearColor(0.0,0.0,0.0,0.0); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_2D); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); resize(pWindow->getWidth(), pWindow->getHeight()); //resize /*HWND hwnd; Trace("Initializing OpenGL graphics driver"); hwnd = static_cast< HWND > (pWindow->getWindowHandle()); // Create an OpenGL pixel format descriptor PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor 1, // Version Number PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Format Must Support OpenGL and double buffering PFD_TYPE_RGBA, // Request An RGBA Format pWindow->getBpp(), // Select Our Color Depth 0, 0, 0, 0, 0, 0, // Color Bits Ignored 0, // No Alpha Buffer 0, // Shift Bit Ignored 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 16, // 16Bit Z-Buffer (Depth Buffer) 0, // No Stencil Buffer 0, // No Auxiliary Buffer PFD_MAIN_PLANE, // Main Drawing Layer 0, // Reserved 0, 0, 0 // Layer Masks Ignored }; // Initialise stuff, and check for errors Trace("Acquiring device context"); if (!(hdc = GetDC(hwnd))) CEngine::CriticalError("Unable to create GL device context!"); Trace("Finding pixel format"); if (!(pixelFormat = ChoosePixelFormat(hdc, &pfd))) CEngine::CriticalError("Unable to find a pixel format!"); Trace("Setting pixel format"); if(!SetPixelFormat(hdc, pixelFormat, &pfd)) CEngine::CriticalError("Unable to set the pixel format!"); Trace("Acquiring rendering context"); if(!(hrc = wglCreateContext(hdc))) CEngine::CriticalError("Unable to create GL rendering context!"); Trace("Setting current GL window"); if(!wglMakeCurrent(hdc, hrc)) CEngine::CriticalError("Unable to activate GL rendering context!"); resize(pWindow->getWidth(), pWindow->getHeight()); // Set up initial gl parameters glClearColor(0.0f, 0.0f, 0.0f, 0.5f); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glClearColor(0.0,0.0,0.0,0.0); glDepthFunc(GL_LEQUAL); glEnable(GL_TEXTURE_2D); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_VERTEX_ARRAY); // Grab GL vendor information Trace("Getting OpenGL driver info ..."); char* str; str = (char*)glGetString(GL_VENDOR); vendor.assign(str); Trace("OpenGL Vendor: %s", vendor.c_str()); str = (char*)glGetString(GL_RENDERER); renderer.assign(str); Trace("OpenGL Renderer: %s", renderer.c_str()); str = (char*)glGetString(GL_VERSION); version.assign(str); Trace("OpenGL Version: %s", version.c_str()); str = (char*)glGetString(GL_EXTENSIONS); extensions.assign(str); // Replace all spaces with newlines for(int i = 0; i < extensions.length(); ++i) { if(extensions[i] == ' ') extensions[i] = '\n'; } // Acquire pointer to extension functions // Multitexturing glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB"); glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)wglGetProcAddress("glClientActiveTextureARB"); glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB"); // Set up hardware gamma, if we are using it if(Config::getIntValue("UseHardwareGamma") == 1) { GetDeviceGammaRamp(hdc, &oldGamma); float gamma = 2.0f; for(int i = 0; i < 3; i++) { for(int j = 0;j < 256; j++) { DWORD d = oldGamma[j][i] * gamma; if(d > 65535) d = 65535; newGamma[j][i] = d; } } SetDeviceGammaRamp(hdc, &newGamma); } // Set up the font HFONT oldfont; fontDispListBase = glGenLists(96); font = CreateFont(-17, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH, "Arial"); oldfont = (HFONT)SelectObject(hdc, font); wglUseFontBitmaps(hdc, 32, 96, fontDispListBase); SelectObject(hdc, oldfont); DeleteObject(font); */ return 0; }
void GLWidget::paintGL() { qglClearColor(Qt::black); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatef(0.0f, 0.0f, -10.0f); glVertexPointer(3, GL_FLOAT, 0, m_vertices.constData()); glTexCoordPointer(2, GL_FLOAT, 0, m_texCoords.constData()); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH); glDepthFunc(GL_ALWAYS); if(m_transparencyGridType != GRID_NONE) { glViewport(0, 0, m_widgetSize.width(), m_widgetSize.height()); m_gridProgram->bind(); m_gridProgram->setUniformValue("windowSize", QVector2D((float)m_widgetSize.width(), (float)m_widgetSize.height())); m_gridProgram->setUniformValue("gridSize", 16.0f); switch(m_transparencyGridType) { case GRID_LIGHT: m_gridProgram->setUniformValue("colorA",QVector3D(1.0,1.0,1.0)); m_gridProgram->setUniformValue("colorB",QVector3D(0.8,0.8,0.8)); break; case GRID_DARK: m_gridProgram->setUniformValue("colorA",QVector3D(0.2,0.2,0.2)); m_gridProgram->setUniformValue("colorB",QVector3D(0.4,0.4,0.4)); break; } glDrawArrays(GL_TRIANGLE_FAN, 0, 4); m_gridProgram->release(); } glViewport(m_viewport.left(), m_viewport.top(), m_viewport.width(), m_viewport.height()); switch(m_displayMode) { case MODE_UV: glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_mapTexture); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, m_displayTexture); m_uvMapProgram->bind(); m_uvMapProgram->setUniformValue("mapTex", 0); m_uvMapProgram->setUniformValue("displayTex", 1); m_uvMapProgram->setUniformValue("transparency", m_showTransparency); break; case MODE_RAW: glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_rawTexture); } glDrawArrays(GL_TRIANGLE_FAN, 0, 4); if(m_displayMode == MODE_UV) { m_uvMapProgram->release(); } glDisable(GL_BLEND); glDisable(GL_DEPTH); }
bool Engine::BootGL() { const GLubyte* card = glGetString(GL_VERSION); if(!card) { DevError("Unable to detect OpenGL version, critical error!!!"); return false; } else { DevDrop("OpenGL Version detected:%s",card); } SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 8); // SDL_GLattr(SDL_GL_SWAP_CONTROL,0); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnable(GL_DEPTH_TEST); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); GLenum glewError = glewInit(); if(glewError != GLEW_OK) { DevError("Error initializing GLEW!!! Aborting Startup!!!"); Sleep(5000); exit(0); } else { DevDrop("GLEW Successfully initialized."); } if(GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader) DevDrop("GLSL Prepared"); else DevError("GLSL Not prepared"); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glShadeModel (GL_SMOOTH); glDepthFunc(GL_LEQUAL); glAlphaFunc ( GL_GREATER, 0.45 ) ; glEnable ( GL_ALPHA_TEST ) ; glClearColor(0.0,0.0,0.0,1.0); glViewport(0, 0, Window->w,Window->h); glOrtho(0.0,(GLdouble)Window->w, (GLdouble)Window->h,0.0,0.0,1.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); #ifdef _DEBUG DevDrop("OpenGL Booted!"); #endif // _DEBUG GraphicsM.SetupFBO(); return true; }
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; }
void visualisation_render() { struct sVect3D camera; u32 j, robot_idx = 0; glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glMatrixMode(GL_MODELVIEW); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glMatrixMode(GL_MODELVIEW); glClearColor(0.0, 0.0, 0.0, 0.0); switch (g_visualisation.view_state) { case 0: glTranslatef(0.0, 0.0, -14.0); glRotatef(0.0, 1.0, 0.0, 0.0); break; case 1: glTranslatef(0.0, 0.0, 0.0); glRotatef(-70.0, 1.0, 0.0, 0.0); glRotatef(g_visualisation.angle, 0.0, 0.0, 1.0); g_visualisation.angle+= 0.4; break; case 2: glTranslatef(0.0, -1.0, -18.5); glRotatef(-70.0, 1.0, 0.0, 0.0); glRotatef(g_visualisation.angle, 0.0, 0.0, 1.0); g_visualisation.angle+= 0.4; break; } /* glTranslatef(0.0, 0.0, -4.5); glRotatef(0.0, 1.0, 0.0, 0.0); */ /* glTranslatef(0.0, 0.0, -2.5); glRotatef(-70.0, 1.0, 0.0, 0.0); */ glClearColor(0.0, 0.0, 0.0, 0.0); struct sRobot robot; g_visualisation.mutex.lock(); for (j = 0; j < g_visualisation.robots.size(); j++) { robot = g_visualisation.robots[j]; visualisation_paint_robot(robot, g_visualisation.base_size); } g_visualisation.mutex.unlock(); glutSwapBuffers(); }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); GLFWwindow* window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", nullptr, nullptr); glfwMakeContextCurrent(window); // Set the required callback functions glfwSetKeyCallback(window, key_callback); glfwSetCursorPosCallback(window, mouse_callback); glfwSetScrollCallback(window, scroll_callback); // Options glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); // Initialize GLEW to setup the OpenGL Function pointers glewExperimental = GL_TRUE; glewInit(); // Define the viewport dimensions glViewport(0, 0, screenWidth, screenHeight); // Setup some OpenGL options glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); // Setup and compile our shaders Shader shader("./advanced.vs", "./advanced.frag"); Shader skyboxShader("./skybox.vs", "./skybox.frag"); #pragma region "object_initialization" // Set the object data (buffers, vertex attributes) GLfloat vertices[] = { -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f }; GLfloat skyboxVertices[] = { // Positions -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f }; // Setup cube VAO GLuint cubeVAO, cubeVBO; glGenVertexArrays(1, &cubeVAO); glGenBuffers(1, &cubeVBO); glBindVertexArray(cubeVAO); glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glBindVertexArray(0); // Setup skybox VAO GLuint skyboxVAO, skyboxVBO; glGenVertexArrays(1, &skyboxVAO); glGenBuffers(1, &skyboxVBO); glBindVertexArray(skyboxVAO); glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO); glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); glBindVertexArray(0); // Load textures GLuint cubeTexture = loadTexture("./container.jpg"); #pragma endregion // Cubemap (Skybox) vector<const GLchar*> faces; faces.push_back("skybox/right.jpg"); faces.push_back("skybox/left.jpg"); faces.push_back("skybox/top.jpg"); faces.push_back("skybox/bottom.jpg"); faces.push_back("skybox/back.jpg"); faces.push_back("skybox/front.jpg"); GLuint cubemapTexture = loadCubemap(faces); while (!glfwWindowShouldClose(window)) { // Set frame time GLfloat currentFrame = glfwGetTime(); deltaTime = currentFrame - lastFrame; lastFrame = currentFrame; // Check and call events glfwPollEvents(); Do_Movement(); // Clear buffers glClearColor(0.1f, 0.1f, 0.1f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Draw skybox first glDepthMask(GL_FALSE);// Remember to turn depth writing off skyboxShader.Use(); glm::mat4 view = glm::mat4(glm::mat3(camera.GetViewMatrix())); // Remove any translation component of the view matrix glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth/(float)screenHeight, 0.1f, 100.0f); glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); // skybox cube glBindVertexArray(skyboxVAO); glActiveTexture(GL_TEXTURE0); glUniform1i(glGetUniformLocation(shader.Program, "skybox"), 0); glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); glDepthMask(GL_TRUE); // Then draw scene as normal shader.Use(); glm::mat4 model; view = camera.GetViewMatrix(); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); // Cubes glBindVertexArray(cubeVAO); glActiveTexture(GL_TEXTURE0); glUniform1i(glGetUniformLocation(shader.Program, "skybox"), 0); glUniform3f(glGetUniformLocation(shader.Program, "cameraPos"), camera.Position.x, camera.Position.y, camera.Position.z); glBindTexture(GL_TEXTURE_2D, cubeTexture); glDrawArrays(GL_TRIANGLES, 0, 36); glBindVertexArray(0); // Swap the buffers glfwSwapBuffers(window); } return 0; }
void OpenGlImplement::InitShaders() { /////CHECK VERSION OF OPENGL///// //char message [200]; //strcpy (message, (char *)glGetString(GL_VERSION)); //strcat (message, "\n\nEs necesario tener la versinn 3.2 para que funcione adecuadamente.\nSi no es tu caso, actualiza tus Driver de video.\nPrecione ENTER para continuar. "); //SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,"OpenGL Version: ", (const char *)message,NULL); //Success flag bool success = true; //Generate program shaderProgram = glCreateProgram(); GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); // Read shaders std::string vertShaderStr = readFile("vertex.glsl"); std::string fragShaderStr = readFile("fragment.glsl"); const GLchar *vertexShaderSource = vertShaderStr.c_str(); const GLchar *fragmentShaderSource = fragShaderStr.c_str(); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glCompileShader(vertexShader); GLint vShaderCompiled = GL_FALSE; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &vShaderCompiled); if (vShaderCompiled != GL_TRUE) printf("Unable to compile vertex shader %d!\n", vertexShader); glAttachShader(shaderProgram, vertexShader); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glCompileShader(fragmentShader); GLint fShaderCompiled = GL_FALSE; glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &fShaderCompiled); if (fShaderCompiled != GL_TRUE) printf("Unable to compile fragment shader %d!\n", fragmentShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); GLint programSuccess = GL_TRUE; glGetProgramiv(shaderProgram, GL_LINK_STATUS, &programSuccess); if (programSuccess != GL_TRUE) printf("Error linking program %d!\n", shaderProgram); //Get vertex attribute location vertexPositionAttribute = glGetAttribLocation(shaderProgram, "aVertexPosition"); vertexTextureCoordAttribute = glGetAttribLocation(shaderProgram, "aTextureCoord"); samplerUniform = glGetUniformLocation(shaderProgram, "uSampler"); //Initialize clear color glClearColor(0.6f, 0.6f, 0.6f, 1.f); glViewport(0, 0, WIDTH_SCREEN, HEIGHT_SCREEN); //glClearDepth(1.0f); // Set background depth to farthest glEnable(GL_DEPTH_TEST); // Enable depth testing for z-culling glDepthFunc(GL_ALWAYS); // Set the type of depth-test glShadeModel(GL_SMOOTH); // Enable smooth shading glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Nice perspective corrections }
bool initialize(){ // Initialize basic geometry and shaders for this example //this defines a cube, this is why a model loader is nice //you can also do this with a draw elements and indices, try to get that working Vertex geometry[] = { {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{-1.0, -1.0, -1.0}, {0.0, 0.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{-1.0, -1.0, 1.0}, {0.0, 0.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{1.0, -1.0, -1.0}, {1.0, 0.0, 0.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{1.0, 1.0, -1.0}, {1.0, 1.0, 0.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{-1.0, 1.0, -1.0}, {0.0, 1.0, 0.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}}, {{-1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}}, {{1.0, -1.0, 1.0}, {1.0, 0.0, 1.0}} }; // Create a Vertex Buffer object to store this vertex info on the GPU glGenBuffers(1, &vbo_geometry); glBindBuffer(GL_ARRAY_BUFFER, vbo_geometry); glBufferData(GL_ARRAY_BUFFER, sizeof(geometry), geometry, GL_STATIC_DRAW); //--Geometry done GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER); GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); //Shader Sources // Put these into files and write a loader in the future // Note the added uniform! const char *vs; vs = shaderLoader("vertexShader"); const char *fs; fs = shaderLoader("fragmentShader"); //compile the shaders GLint shader_status; // Vertex shader first glShaderSource(vertex_shader, 1, &vs, NULL); glCompileShader(vertex_shader); //check the compile status glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] FAILED TO COMPILE VERTEX SHADER!" << std::endl; return false; } // Now the Fragment shader glShaderSource(fragment_shader, 1, &fs, NULL); glCompileShader(fragment_shader); //check the compile status glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] FAILED TO COMPILE FRAGMENT SHADER!" << std::endl; return false; } //Now we link the 2 shader objects into a program //This program is what is run on the GPU program = glCreateProgram(); glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glLinkProgram(program); //check if everything linked ok glGetProgramiv(program, GL_LINK_STATUS, &shader_status); if(!shader_status){ std::cerr << "[F] THE SHADER PROGRAM FAILED TO LINK" << std::endl; return false; } //Now we set the locations of the attributes and uniforms //this allows us to access them easily while rendering loc_position = glGetAttribLocation(program, const_cast<const char*>("v_position")); if(loc_position == -1){ std::cerr << "[F] POSITION NOT FOUND" << std::endl; return false; } loc_color = glGetAttribLocation(program, const_cast<const char*>("v_color")); if(loc_color == -1){ std::cerr << "[F] V_COLOR NOT FOUND" << std::endl; return false; } loc_mvpmat = glGetUniformLocation(program, const_cast<const char*>("mvpMatrix")); if(loc_mvpmat == -1){ std::cerr << "[F] MVPMATRIX NOT FOUND" << std::endl; return false; } //--Init the view and projection matrices // if you will be having a moving camera the view matrix will need to more dynamic // ...Like you should update it before you render more dynamic // for this project having them static will be fine view = glm::lookAt( glm::vec3(0.0, 8.0, -16.0), //Eye Position glm::vec3(0.0, 0.0, 0.0), //Focus point glm::vec3(0.0, 1.0, 0.0)); //Positive Y is up projection = glm::perspective( 45.0f, //the FoV typically 90 degrees is good which is what this is set to float(w)/float(h), //Aspect Ratio, so Circles stay Circular 0.01f, //Distance to the near plane, normally a small value like this 100.0f); //Distance to the far plane, //enable depth testing glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); //and its done return true; }
int main(int argc, char *argv[]){ if(!glfwInit()){ throw std::runtime_error("glfwInit failed"); } glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); glfwOpenWindowHint(0, GLFW_OPENGL_CORE_PROFILE); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1); glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE); if(!glfwOpenWindow(800, 600, 0, 0, 0, 0, 32, 0, GLFW_WINDOW)){ throw std::runtime_error("glfwOpenWindow failed. does this hardware work with 3.1"); } glewExperimental = GL_TRUE; if(glewInit() != GLEW_OK){ throw std::runtime_error("glewInit failed"); } if(!GLEW_VERSION_3_1){ throw std::runtime_error("OpenGL 3.1 API is not available"); } LoadGeometry(); LoadTexture(); PrepVertexUniforms(); camera.setPosition(glm::vec3(0,0,8)); camera.setViewportAspectRatio(screenwidth/screenheight); light.position = camera.position(); light.intensities = glm::vec3(1,1,1); glfwDisable(GLFW_MOUSE_CURSOR); glfwSetMousePos(0, 0); glfwSetMouseWheel(0); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); while(glfwGetWindowParam(GLFW_OPENED)){ update(); display(); //check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR){ glPrintError(); } //esc == close if(glfwGetKey(GLFW_KEY_ESC)){ glfwCloseWindow(); } } glfwTerminate(); return 0; }
void Camera::clearBackground(float depth) { GLboolean oldDepthTest; GLint oldDepthFunc; GLboolean oldDepthMask; { glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glStencilMask(0); oldDepthTest = glIsEnabled(GL_DEPTH_TEST); glGetIntegerv(GL_DEPTH_FUNC, &oldDepthFunc); glGetBooleanv(GL_DEPTH_WRITEMASK, &oldDepthMask); glDepthMask(GL_TRUE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_ALWAYS); } //draw static V3F_C4B_T2F_Quad quad; quad.bl.vertices = Vec3(-1,-1,0); quad.br.vertices = Vec3(1,-1,0); quad.tl.vertices = Vec3(-1,1,0); quad.tr.vertices = Vec3(1,1,0); quad.bl.colors = quad.br.colors = quad.tl.colors = quad.tr.colors = Color4B(0,0,0,1); quad.bl.texCoords = Tex2F(0,0); quad.br.texCoords = Tex2F(1,0); quad.tl.texCoords = Tex2F(0,1); quad.tr.texCoords = Tex2F(1,1); auto shader = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_CAMERA_CLEAR); auto programState = GLProgramState::getOrCreateWithGLProgram(shader); programState->setUniformFloat("depth", 1.0); programState->apply(Mat4()); GLshort indices[6] = {0, 1, 2, 3, 2, 1}; { GL::bindVAO(0); glBindBuffer(GL_ARRAY_BUFFER, 0); GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX); // vertices glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &quad.tl.vertices); // colors glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V3F_C4B_T2F), &quad.tl.colors); // tex coords glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &quad.tl.texCoords); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices); } { if(GL_FALSE == oldDepthTest) { glDisable(GL_DEPTH_TEST); } glDepthFunc(oldDepthFunc); if(GL_FALSE == oldDepthMask) { glDepthMask(GL_FALSE); } /* IMPORTANT: We only need to update the states that are not restored. Since we don't know what was the previous value of the mask, we update the RenderState after setting it. The other values don't need to be updated since they were restored to their original values */ glStencilMask(0xFFFFF); // RenderState::StateBlock::_defaultState->setStencilWrite(0xFFFFF); /* BUG: RenderState does not support glColorMask yet. */ glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } }
void GraphicsWindow::Paint(void) { int i; havePainted = true; int w, h; GetGraphicsWindowSize(&w, &h); width = w; height = h; glViewport(0, 0, w, h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glScaled(scale*2.0/w, scale*2.0/h, scale*1.0/30000); double mat[16]; // Last thing before display is to apply the perspective double clp = SS.CameraTangent()*scale; MakeMatrix(mat, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, clp, 1); glMultMatrixd(mat); // Before that, we apply the rotation Vector n = projUp.Cross(projRight); MakeMatrix(mat, projRight.x, projRight.y, projRight.z, 0, projUp.x, projUp.y, projUp.z, 0, n.x, n.y, n.z, 0, 0, 0, 0, 1); glMultMatrixd(mat); // And before that, the translation MakeMatrix(mat, 1, 0, 0, offset.x, 0, 1, 0, offset.y, 0, 0, 1, offset.z, 0, 0, 0, 1); glMultMatrixd(mat); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel(GL_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); // don't enable GL_POLYGON_SMOOTH; that looks ugly on some graphics cards, // drawn with leaks in the mesh glEnable(GL_POLYGON_OFFSET_LINE); glEnable(GL_POLYGON_OFFSET_FILL); glEnable(GL_DEPTH_TEST); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); glEnable(GL_NORMALIZE); // At the same depth, we want later lines drawn over earlier. glDepthFunc(GL_LEQUAL); if(SS.AllGroupsOkay()) { glClearColor(REDf(SS.backgroundColor), GREENf(SS.backgroundColor), BLUEf(SS.backgroundColor), 1.0f); } else { // Draw a different background whenever we're having solve problems. DWORD rgb = Style::Color(Style::DRAW_ERROR); glClearColor(0.4f*REDf(rgb), 0.4f*GREENf(rgb), 0.4f*BLUEf(rgb), 1.0f); // And show the text window, which has info to debug it ForceTextWindowShown(); } glClear(GL_COLOR_BUFFER_BIT); glClearDepth(1.0); glClear(GL_DEPTH_BUFFER_BIT); if(SS.bgImage.fromFile) { // If a background image is loaded, then we draw it now as a texture. // This handles the resizing for us nicely. glBindTexture(GL_TEXTURE_2D, TEXTURE_BACKGROUND_IMG); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, SS.bgImage.rw, SS.bgImage.rh, 0, GL_RGB, GL_UNSIGNED_BYTE, SS.bgImage.fromFile); double tw = ((double)SS.bgImage.w) / SS.bgImage.rw, th = ((double)SS.bgImage.h) / SS.bgImage.rh; double mmw = SS.bgImage.w / SS.bgImage.scale, mmh = SS.bgImage.h / SS.bgImage.scale; Vector origin = SS.bgImage.origin; origin = origin.DotInToCsys(projRight, projUp, n); // Place the depth of our origin at the point that corresponds to // w = 1, so that it's unaffected by perspective. origin.z = (offset.ScaledBy(-1)).Dot(n); origin = origin.ScaleOutOfCsys(projRight, projUp, n); // Place the background at the very back of the Z order, though, by // mucking with the depth range. glDepthRange(1, 1); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glTexCoord2d(0, 0); glxVertex3v(origin); glTexCoord2d(0, th); glxVertex3v(origin.Plus(projUp.ScaledBy(mmh))); glTexCoord2d(tw, th); glxVertex3v(origin.Plus(projRight.ScaledBy(mmw).Plus( projUp. ScaledBy(mmh)))); glTexCoord2d(tw, 0); glxVertex3v(origin.Plus(projRight.ScaledBy(mmw))); glEnd(); glDisable(GL_TEXTURE_2D); } glxDepthRangeOffset(0); // Nasty case when we're reloading the imported files; could be that // we get an error, so a dialog pops up, and a message loop starts, and // we have to get called to paint ourselves. If the sketch is screwed // up, then we could trigger an oops trying to draw. if(!SS.allConsistent) return; // Let's use two lights, at the user-specified locations GLfloat f; glEnable(GL_LIGHT0); f = (GLfloat)SS.lightIntensity[0]; GLfloat li0[] = { f, f, f, 1.0f }; glLightfv(GL_LIGHT0, GL_DIFFUSE, li0); glLightfv(GL_LIGHT0, GL_SPECULAR, li0); glEnable(GL_LIGHT1); f = (GLfloat)SS.lightIntensity[1]; GLfloat li1[] = { f, f, f, 1.0f }; glLightfv(GL_LIGHT1, GL_DIFFUSE, li1); glLightfv(GL_LIGHT1, GL_SPECULAR, li1); Vector ld; ld = VectorFromProjs(SS.lightDir[0]); GLfloat ld0[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 }; glLightfv(GL_LIGHT0, GL_POSITION, ld0); ld = VectorFromProjs(SS.lightDir[1]); GLfloat ld1[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 }; glLightfv(GL_LIGHT1, GL_POSITION, ld1); if(SS.drawBackFaces) { // For debugging, draw the backs of the triangles in red, so that we // notice when a shell is open glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1); } else { glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0); } GLfloat ambient[4] = { (float)SS.ambientIntensity, (float)SS.ambientIntensity, (float)SS.ambientIntensity, 1 }; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient); glxUnlockColor(); if(showSnapGrid && LockedInWorkplane()) { hEntity he = ActiveWorkplane(); EntityBase *wrkpl = SK.GetEntity(he), *norm = wrkpl->Normal(); Vector wu, wv, wn, wp; wp = SK.GetEntity(wrkpl->point[0])->PointGetNum(); wu = norm->NormalU(); wv = norm->NormalV(); wn = norm->NormalN(); double g = SS.gridSpacing; double umin = VERY_POSITIVE, umax = VERY_NEGATIVE, vmin = VERY_POSITIVE, vmax = VERY_NEGATIVE; int a; for(a = 0; a < 4; a++) { // Ideally, we would just do +/- half the width and height; but // allow some extra slop for rounding. Vector horiz = projRight.ScaledBy((0.6*width)/scale + 2*g), vert = projUp. ScaledBy((0.6*height)/scale + 2*g); if(a == 2 || a == 3) horiz = horiz.ScaledBy(-1); if(a == 1 || a == 3) vert = vert. ScaledBy(-1); Vector tp = horiz.Plus(vert).Minus(offset); // Project the point into our grid plane, normal to the screen // (not to the grid plane). If the plane is on edge then this is // impossible so don't try to draw the grid. bool parallel; Vector tpp = Vector::AtIntersectionOfPlaneAndLine( wn, wn.Dot(wp), tp, tp.Plus(n), ¶llel); if(parallel) goto nogrid; tpp = tpp.Minus(wp); double uu = tpp.Dot(wu), vv = tpp.Dot(wv); umin = min(uu, umin); umax = max(uu, umax); vmin = min(vv, vmin); vmax = max(vv, vmax); } int i, j, i0, i1, j0, j1; i0 = (int)(umin / g); i1 = (int)(umax / g); j0 = (int)(vmin / g); j1 = (int)(vmax / g); if(i0 > i1 || i1 - i0 > 400) goto nogrid; if(j0 > j1 || j1 - j0 > 400) goto nogrid; glLineWidth(1); glxColorRGBa(Style::Color(Style::DATUM), 0.3); glBegin(GL_LINES); for(i = i0 + 1; i < i1; i++) { glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j0*g))); glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j1*g))); } for(j = j0 + 1; j < j1; j++) { glxVertex3v(wp.Plus(wu.ScaledBy(i0*g)).Plus(wv.ScaledBy(j*g))); glxVertex3v(wp.Plus(wu.ScaledBy(i1*g)).Plus(wv.ScaledBy(j*g))); } glEnd(); // Clear the depth buffer, so that the grid is at the very back of // the Z order. glClear(GL_DEPTH_BUFFER_BIT); nogrid:; } // Draw the active group; this does stuff like the mesh and edges. (SK.GetGroup(activeGroup))->Draw(); // Now draw the entities if(showHdnLines) glDisable(GL_DEPTH_TEST); Entity::DrawAll(); // Draw filled paths in all groups, when those filled paths were requested // specially by assigning a style with a fill color, or when the filled // paths are just being filled by default. This should go last, to make // the transparency work. Group *g; for(g = SK.group.First(); g; g = SK.group.NextAfter(g)) { if(!(g->IsVisible())) continue; g->DrawFilledPaths(); } glDisable(GL_DEPTH_TEST); // Draw the constraints for(i = 0; i < SK.constraint.n; i++) { SK.constraint.elem[i].Draw(); } // Draw the traced path, if one exists glLineWidth(Style::Width(Style::ANALYZE)); glxColorRGB(Style::Color(Style::ANALYZE)); SContour *sc = &(SS.traced.path); glBegin(GL_LINE_STRIP); for(i = 0; i < sc->l.n; i++) { glxVertex3v(sc->l.elem[i].p); } glEnd(); // And the naked edges, if the user did Analyze -> Show Naked Edges. glLineWidth(Style::Width(Style::DRAW_ERROR)); glxColorRGB(Style::Color(Style::DRAW_ERROR)); glxDrawEdges(&(SS.nakedEdges), true); // Then redraw whatever the mouse is hovering over, highlighted. glDisable(GL_DEPTH_TEST); glxLockColorTo(Style::Color(Style::HOVERED)); hover.Draw(); // And finally draw the selection, same mechanism. glxLockColorTo(Style::Color(Style::SELECTED)); for(Selection *s = selection.First(); s; s = selection.NextAfter(s)) { s->Draw(); } glxUnlockColor(); // If a marquee selection is in progress, then draw the selection // rectangle, as an outline and a transparent fill. if(pending.operation == DRAGGING_MARQUEE) { Point2d begin = ProjectPoint(orig.marqueePoint); double xmin = min(orig.mouse.x, begin.x), xmax = max(orig.mouse.x, begin.x), ymin = min(orig.mouse.y, begin.y), ymax = max(orig.mouse.y, begin.y); Vector tl = UnProjectPoint(Point2d::From(xmin, ymin)), tr = UnProjectPoint(Point2d::From(xmax, ymin)), br = UnProjectPoint(Point2d::From(xmax, ymax)), bl = UnProjectPoint(Point2d::From(xmin, ymax)); glLineWidth((GLfloat)1.3); glxColorRGB(Style::Color(Style::HOVERED)); glBegin(GL_LINE_LOOP); glxVertex3v(tl); glxVertex3v(tr); glxVertex3v(br); glxVertex3v(bl); glEnd(); glxColorRGBa(Style::Color(Style::HOVERED), 0.10); glBegin(GL_QUADS); glxVertex3v(tl); glxVertex3v(tr); glxVertex3v(br); glxVertex3v(bl); glEnd(); } // An extra line, used to indicate the origin when rotating within the // plane of the monitor. if(SS.extraLine.draw) { glLineWidth(1); glxLockColorTo(Style::Color(Style::DATUM)); glBegin(GL_LINES); glxVertex3v(SS.extraLine.ptA); glxVertex3v(SS.extraLine.ptB); glEnd(); } // A note to indicate the origin in the just-exported file. if(SS.justExportedInfo.draw) { glxColorRGB(Style::Color(Style::DATUM)); Vector p = SS.justExportedInfo.pt, u = SS.justExportedInfo.u, v = SS.justExportedInfo.v; glLineWidth(1.5); glBegin(GL_LINES); glxVertex3v(p.Plus(u.WithMagnitude(-15/scale))); glxVertex3v(p.Plus(u.WithMagnitude(30/scale))); glxVertex3v(p.Plus(v.WithMagnitude(-15/scale))); glxVertex3v(p.Plus(v.WithMagnitude(30/scale))); glEnd(); glxWriteText("(x, y) = (0, 0) for file just exported", DEFAULT_TEXT_HEIGHT, p.Plus(u.ScaledBy(10/scale)).Plus(v.ScaledBy(10/scale)), u, v, NULL, NULL); glxWriteText("press Esc to clear this message", DEFAULT_TEXT_HEIGHT, p.Plus(u.ScaledBy(40/scale)).Plus( v.ScaledBy(-(DEFAULT_TEXT_HEIGHT)/scale)), u, v, NULL, NULL); } // And finally the toolbar. if(SS.showToolbar) { ToolbarDraw(); } }
int main(int argc, char* argv[]) { window = queso::init(argc, argv, "Lesson 5: Basic transforms"); // Register callbacks glfwSetWindowSizeCallback(window, window_callback); // Setup OpenGL glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); // TODO(rgayle): Is this necessary? // Set up a triangle. float points[] = { 0.0f, 0.5f, 0.0f, 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f }; float colors[] = { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // VBOs unsigned int points_vbo = 0; glGenBuffers(1, &points_vbo); glBindBuffer(GL_ARRAY_BUFFER, points_vbo); glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(float), points, GL_STATIC_DRAW); unsigned int colors_vbo = 0; glGenBuffers(1, &colors_vbo); glBindBuffer(GL_ARRAY_BUFFER, colors_vbo); glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(float), colors, GL_STATIC_DRAW); unsigned int vao = 0; glGenVertexArrays(1, &vao); glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, points_vbo); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); // points are idx 0 glBindBuffer(GL_ARRAY_BUFFER, colors_vbo); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); // colors are idx 1 glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); // Shaders and shader program queso::Shader vs("shaders/no_perspective.vert", queso::VERTEX, true); queso::Shader fs("shaders/uniform_color.frag", queso::FRAGMENT, true); queso::ShaderProgram prog(vs, fs); prog.use(); // Simple vertex transform float last_pos = 0.5f; float rot = 0.5f; // in radians glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(last_pos, 0.0f, 0.0f)); glm::mat4 rotate = glm::rotate(translate, rot, glm::vec3(0.0f, 0.0f, 1.0f)); // Set the transform prog.setUniform("matrix", queso::FOUR_BY_FOUR, GL_FALSE, glm::value_ptr(rotate)); // Other setup glClearColor(0.1f, 0.1f, 0.3f, 1.0f); // Variables for moving the triangle. float speed = 1.0f; float rot_speed = 0.5f; // Set up our drawing loop while (!glfwWindowShouldClose(window)) { // Timer, for animations. static double previousTime = glfwGetTime(); double currTime = glfwGetTime(); double elapsedTime = currTime - previousTime; previousTime = currTime; // ReverseDirection if we get too far left or right if (fabs(last_pos) > 1.0f) { if (last_pos < 0) last_pos = -1.0f; else last_pos = 1.0; speed *= -1; } // Update our matrix if (!queso::paused) { last_pos += elapsedTime * speed; rot += elapsedTime * rot_speed; translate = glm::translate(glm::mat4(1.0f), glm::vec3(last_pos, 0.0f, 0.0f)); rotate = glm::rotate(translate, rot, glm::vec3(0.0f, 0.0f, 1.0f)); prog.setUniform("matrix", queso::FOUR_BY_FOUR, GL_FALSE, glm::value_ptr(rotate)); } // Clear glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport(0, 0, width, height); // Shape 1 prog.use(); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, 6); // Put it on the screen! glfwSwapBuffers(window); // Poll for input handling glfwPollEvents(); } glfwTerminate(); return 0; }
int main(int argc, char *argv[]) { int fsaa, accel; int value; int i, done; SDL_DisplayMode mode; SDL_Event event; Uint32 then, now, frames; int status; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Initialize parameters */ fsaa = 0; accel = 0; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { if (SDL_strcasecmp(argv[i], "--fsaa") == 0) { ++fsaa; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--accel") == 0) { ++accel; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--zdepth") == 0) { i++; if (!argv[i]) { consumed = -1; } else { depth = SDL_atoi(argv[i]); consumed = 1; } } else { consumed = -1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--fsaa] [--accel] [--zdepth %%d]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } /* Set OpenGL parameters */ state->window_flags |= SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS; state->gl_red_size = 5; state->gl_green_size = 5; state->gl_blue_size = 5; state->gl_depth_size = depth; state->gl_major_version = 1; state->gl_minor_version = 1; state->gl_profile_mask = SDL_GL_CONTEXT_PROFILE_ES; if (fsaa) { state->gl_multisamplebuffers=1; state->gl_multisamplesamples=fsaa; } if (accel) { state->gl_accelerated=1; } if (!SDLTest_CommonInit(state)) { quit(2); } context = SDL_calloc(state->num_windows, sizeof(context)); if (context == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!\n"); quit(2); } /* Create OpenGL ES contexts */ for (i = 0; i < state->num_windows; i++) { context[i] = SDL_GL_CreateContext(state->windows[i]); if (!context[i]) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GL_CreateContext(): %s\n", SDL_GetError()); quit(2); } } if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { SDL_GL_SetSwapInterval(1); } else { SDL_GL_SetSwapInterval(0); } SDL_GetCurrentDisplayMode(0, &mode); SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format)); SDL_Log("\n"); SDL_Log("Vendor : %s\n", glGetString(GL_VENDOR)); SDL_Log("Renderer : %s\n", glGetString(GL_RENDERER)); SDL_Log("Version : %s\n", glGetString(GL_VERSION)); SDL_Log("Extensions : %s\n", glGetString(GL_EXTENSIONS)); SDL_Log("\n"); status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); if (!status) { SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); if (!status) { SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); if (!status) { SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); if (!status) { SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", depth, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError()); } if (fsaa) { status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError()); } } if (accel) { status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); if (!status) { SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError()); } } /* Set rendering settings for each context */ for (i = 0; i < state->num_windows; ++i) { float aspectAdjust; status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); /* Continue for next window */ continue; } aspectAdjust = (4.0f / 3.0f) / ((float)state->window_w / state->window_h); glViewport(0, 0, state->window_w, state->window_h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrthof(-2.0, 2.0, -2.0 * aspectAdjust, 2.0 * aspectAdjust, -20.0, 20.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glShadeModel(GL_SMOOTH); } /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_RESIZED: for (i = 0; i < state->num_windows; ++i) { if (event.window.windowID == SDL_GetWindowID(state->windows[i])) { status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); break; } /* Change view port to the new window dimensions */ glViewport(0, 0, event.window.data1, event.window.data2); /* Update window content */ Render(); SDL_GL_SwapWindow(state->windows[i]); break; } } break; } } SDLTest_CommonEvent(state, &event, &done); } for (i = 0; i < state->num_windows; ++i) { if (state->windows[i] == NULL) continue; status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); /* Continue for next window */ continue; } Render(); SDL_GL_SwapWindow(state->windows[i]); } } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { SDL_Log("%2.2f frames per second\n", ((double) frames * 1000) / (now - then)); } quit(0); return 0; }
void render(int clientWidth, int clientHeight) { GLuint screenVao=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getVao(); GeometryDraw *screenDraw=geometryVaoManager->get(screenGeomFn,positionsVaoFn)->getDraw(); glViewport(0,0,clientWidth,clientHeight); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDisable(GL_BLEND); glDisable(GL_STENCIL_TEST); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); //bind fbo glBindFramebuffer(GL_DRAW_FRAMEBUFFER, deferredFbo); //clear glClearColor(0.0f,0.0f,0.0f,0.0f); glClearDepth(1); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //states glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE); //draw entity geom depths //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //draw entity geoms { for(Mesh *m : scene->getMeshes()) { GLuint prog=0; if(m->material==Mesh::Color) { prog=programManager->get(geometryColoredProgFn); } else if(m->material==Mesh::Parallax) { prog=programManager->get(geometryParallaxProgFn); if(m->reliefTex.empty()) { prog=programManager->get("data/shader/geometry/Parallax2.json"); } else { prog=programManager->get("data/shader/geometry/Parallax.json"); } } if(GLuint tex=textureManager->get2d(m->colorTex)) { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->normalTex)) { glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D,tex); // std::cout << "n " << tex << std::endl; } if(GLuint tex=textureManager->get2d(m->heightTex)) { glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D,tex); } if(GLuint tex=textureManager->get2d(m->reliefTex)) { glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D,tex); } // glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int colLoc=glGetUniformLocation(prog,"u_col"); int shininessLoc=glGetUniformLocation(prog,"u_shininess"); int emissiveLoc=glGetUniformLocation(prog,"u_emissive"); int reflectiveLoc=glGetUniformLocation(prog,"u_reflective"); int bumpScaleLoc=glGetUniformLocation(prog,"u_bumpScale"); int bumpBiasLoc=glGetUniformLocation(prog,"u_bumpBias"); int reliefScaleLoc=glGetUniformLocation(prog,"u_reliefScale"); int parallaxScaleLoc=glGetUniformLocation(prog,"u_parallaxScale"); int parallaxBiasLoc=glGetUniformLocation(prog,"u_parallaxBias"); int parallaxInvertHeightLoc=glGetUniformLocation(prog,"u_parallaxInvertHeight"); int zNearFarLoc=glGetUniformLocation(prog,"u_zNearFar"); // if(colLoc!=-1) { glUniform3fv(colLoc,1,m->color); } glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(modelViewMatLoc!=-1) { glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); } if(normalMatLoc!=-1) { glUniformMatrix3fv(normalMatLoc,1,GL_TRUE,m->normalMat); } if(shininessLoc!=-1) { glUniform1fv(shininessLoc,1,&m->shininess); } if(emissiveLoc!=-1) { glUniform1i(emissiveLoc,m->emissive?1:0); } if(reflectiveLoc!=-1) { glUniform1fv(reflectiveLoc,1,&m->reflective); } // if(bumpScaleLoc!=-1) { glUniform1fv(bumpScaleLoc,1,&m->bumpScale); } if(bumpBiasLoc!=-1) { glUniform1fv(bumpBiasLoc,1,&m->bumpBias); } // if(reliefScaleLoc!=-1) { glUniform1fv(reliefScaleLoc,1,&m->reliefScale); } // if(parallaxScaleLoc!=-1) { glUniform1fv(parallaxScaleLoc,1,&m->parallaxScale); } if(parallaxBiasLoc!=-1) { glUniform1fv(parallaxBiasLoc,1,&m->parallaxBias); } if(parallaxInvertHeightLoc!=-1) { glUniform1i(parallaxInvertHeightLoc,m->parallaxInvertHeight?1:0); } if(zNearFarLoc!=-1) { float zNearFar[2]={m->zNear,m->zFar}; glUniform2fv(zNearFarLoc,1,zNearFar); } // if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } //bind fbo glBindFramebuffer(GL_FRAMEBUFFER, 0); //bind textures glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, deferredColorTex); glBindSampler(0,0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, deferredNormalTex); glBindSampler(1,0); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, deferredDepthTex); glBindSampler(2,0); //states glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDepthFunc(GL_LESS); //clear glClearDepth(1.0f); glClear(GL_DEPTH_BUFFER_BIT); //render deferred depth texture glUseProgram(programManager->get(deferredDepthCopyProgFn)); glBindVertexArray(screenVao); screenDraw->draw(); //states glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glDepthMask(GL_FALSE); //clear glClearColor(0.0f,0.0f,0.0f,1.0f); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); //bind vao glBindVertexArray(screenVao); //states glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights { GLuint p=programManager->get(deferredPointlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightPosLoc=glGetUniformLocation(p,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(p,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Pointlight *pl : scene->getPointlights()) { if(!pl->shadow) { glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); screenDraw->draw(); } } } //draw spot lights { GLuint p=programManager->get(deferredSpotlightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); for(Spotlight *sl : scene->getSpotlights()) { if(!sl->shadow) { } } } //draw directional lights { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); for(Directionallight *dl : scene->getDirectionallights()) { if(!dl->shadow) { glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); screenDraw->draw(); } } } //states glEnable(GL_STENCIL_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); //draw point lights with shadows { // GLuint lightProg=programManager->get(deferredPointlightProgFn); GLuint invProjLoc=glGetUniformLocation(lightProg,"u_invProjMat"); GLint lightPosLoc=glGetUniformLocation(lightProg,"u_lightPos"); GLint lightAttenLoc=glGetUniformLocation(lightProg,"u_lightAtten"); GLint lightColLoc=glGetUniformLocation(lightProg,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(lightProg,"u_strength"); glUseProgram(lightProg); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); // for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); //... bool lastZpass=false; glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.1f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightPosLoc2,1,pl->viewPos); // if(geometryShaderSupport && scene->isGeometryShadows()) { // glEnable(GL_PRIMITIVE_RESTART); for(Shadow *shadow : scene->getShadows()) { if(lastZpass !=shadow->zpass) { lastZpass=shadow->zpass; if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,false); } } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(lightProg); glUniform4fv(lightPosLoc,1,pl->viewPos); glUniform3fv(lightAttenLoc,1,pl->attenuation); glUniform3fv(lightColLoc,1,pl->color); glUniform1fv(strengthLoc,1,&pl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } //draw spot lights with shadows { } //draw directional lights with shadows //if(geometryShaderSupport && scene->isGeometryShadows()) //cpu directional shadows not implemented { GLuint p=programManager->get(deferredDirectionallightProgFn); glUseProgram(p); GLint invProjLoc=glGetUniformLocation(p,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint lightDirLoc=glGetUniformLocation(p,"u_lightDir"); GLint lightColLoc=glGetUniformLocation(p,"u_lightCol"); GLint strengthLoc=glGetUniformLocation(p,"u_strength"); // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); glStencilFunc(GL_ALWAYS, 0, 0xff); glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(0.3f,1.0f); glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //use shadow program glUseProgram(shadowProg); glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(!shadow->zpass) { glStencilOpSeparate(GL_BACK, GL_KEEP, GL_INCR_WRAP, GL_KEEP); glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_DECR_WRAP, GL_KEEP); } else { glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP); glStencilOpSeparate(GL_BACK , GL_KEEP, GL_KEEP, GL_DECR_WRAP); } if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,false); } } } //draw light glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_BLEND); glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_CLAMP); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_KEEP); glStencilFunc(GL_EQUAL, 0, 0xff); glUseProgram(p); glUniform4fv(lightDirLoc,1,dl->viewDir); glUniform3fv(lightColLoc,1,dl->color); glUniform1fv(strengthLoc,1,&dl->strength); glBindVertexArray(screenVao); screenDraw->draw(); } } } // glDisable(GL_STENCIL_TEST); //states glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CCW); glDepthMask(GL_FALSE); glDisable(GL_DEPTH_TEST); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); //bind vao glBindVertexArray(screenVao); //draw ambients { GLuint prog=programManager->get(deferredAmbientProgFn); GLuint ambienceLoc=glGetUniformLocation(prog,"u_ambience"); glUseProgram(prog); glUniform1f(ambienceLoc,0.05f); screenDraw->draw(); } //draw emissives glUseProgram(programManager->get(deferredEmissiveProgFn)); screenDraw->draw(); //bind sky texture to 3 glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_CUBE_MAP,textureManager->getCube(cubeEnvTexFn)); //states glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE); //draw reflections { GLuint prog=programManager->get(deferredReflectionProgFn); glUseProgram(prog); GLint invProjLoc=glGetUniformLocation(prog,"u_invProjMat"); glUniformMatrix4fv(invProjLoc,1,GL_TRUE,scene->getInvProjMat()); GLint viewLoc=glGetUniformLocation(prog,"u_invViewMat"); glUniformMatrix4fv(viewLoc,1,GL_TRUE,scene->getInvViewMat()); screenDraw->draw(); } //states glBlendFunc(GL_ONE, GL_ONE); //draw color test // glUseProgram(programManager->get("")); // screenDraw->draw(); //states glDisable(GL_BLEND); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glEnable(GL_STENCIL_TEST); glStencilFunc(GL_ALWAYS, 0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); //clear stencil glClearStencil(0); glClear(GL_STENCIL_BUFFER_BIT); //stencil out sky area glUseProgram(programManager->get(deferredDepthStencilProg)); screenDraw->draw(); //states glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE); glStencilFunc(GL_EQUAL, 0x0, 0xff); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); //draw sky { GLuint skyProg=programManager->get(skyboxProgFn); GeometryVao *gv=geometryVaoManager->get(skyboxGeomFn,positionsVaoFn); glUseProgram(skyProg); GLuint loc=glGetUniformLocation(skyProg,"u_viewRotProjMat"); glUniformMatrix4fv(loc,1,GL_TRUE,scene->getViewRotProjMat()); glBindVertexArray(gv->getVao()); gv->getDraw()->draw(); } //states glDisable(GL_STENCIL_TEST); glDisable(GL_CULL_FACE); glDisable(GL_BLEND); //glBlendEquation(GL_FUNC_ADD); glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_CLAMP); //point light shadow debug if(scene->isShadowDebug()) { GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(pointLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(pointLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightPosLoc2=glGetUniformLocation(shadowProg,"u_lightPos"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Pointlight *pl : scene->getPointlights()) { if(pl->shadow) { glUniform4fv(lightPosLoc2,1,pl->viewPos); if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow ) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,pl,shadowCpuThreads,true); } } } } } } //directional light shadow debug if(scene->isShadowDebug()) { // GLuint shadowProg=0; GLint zpassLoc2=-1; GLint robustLoc2=-1; if(geometryShaderSupport && scene->isGeometryShadows()) { shadowProg=programManager->get(directionalLightShadowGpuDebugProgFn); zpassLoc2=glGetUniformLocation(shadowProg,"u_zpass"); robustLoc2=glGetUniformLocation(shadowProg,"u_robust"); } else { shadowProg=programManager->get(directionalLightShadowCpuProgFn); } GLint projMatLoc2=glGetUniformLocation(shadowProg,"u_projMat"); GLint modelViewMatLoc2=glGetUniformLocation(shadowProg,"u_modelViewMat"); GLint lightDirLoc2=glGetUniformLocation(shadowProg,"u_lightDir"); glUseProgram(shadowProg); glUniformMatrix4fv(projMatLoc2,1,GL_TRUE,scene->getProjMat()); for(Directionallight *dl : scene->getDirectionallights()) { if(dl->shadow) { //use shadow program glUniform4fv(lightDirLoc2,1,dl->viewDir); // if(geometryShaderSupport && scene->isGeometryShadows()) { for(Shadow *shadow : scene->getShadows()) { glUniform1i(zpassLoc2,shadow->zpass?1:0); glUniform1i(robustLoc2,shadow->robust?1:0); glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE,shadow->modelViewMat); if(GeometryVao *gv=geometryVaoManager->get(shadow->geometry,positionsVaoFn)) { glBindVertexArray(gv->getVao()); gv->getDraw("default")->draw(); } } } else { for(Shadow *shadow : scene->getShadows()) { if(shadow->cpuShadow) { glUniformMatrix4fv(modelViewMatLoc2,1,GL_TRUE, shadow->modelViewMat); shadow->cpuShadow->draw(geometryVaoManager,dl,shadowCpuThreads,true); } } } } } } //states glEnable(GL_CULL_FACE); glDisable(GL_DEPTH_CLAMP); glDepthMask(GL_FALSE); //glDisable(GL_DEPTH_TEST); //glDepthFunc(GL_LESS); //draw normals, triangle normals, tangents, bitangents if(false && geometryShaderSupport) { GLuint prog=programManager->get(normalsDebugProgFn); glUseProgram(prog); int modelViewProjMatLoc=glGetUniformLocation(prog,"u_modelViewProjMat"); int modelViewMatLoc=glGetUniformLocation(prog,"u_modelViewMat"); int normalMatLoc=glGetUniformLocation(prog,"u_normalMat"); int projLoc=glGetUniformLocation(prog,"u_projMat"); if(projLoc!=-1) glUniformMatrix4fv(projLoc,1,GL_TRUE,scene->getProjMat() ); for(Mesh *m : scene->getMeshes()) { if(modelViewProjMatLoc!=-1) glUniformMatrix4fv(modelViewProjMatLoc,1,GL_TRUE,m->modelViewProjMat); if(normalMatLoc!=-1) glUniformMatrix4fv(normalMatLoc,1,GL_TRUE,m->normalMat); if(modelViewMatLoc!=-1) glUniformMatrix4fv(modelViewMatLoc,1,GL_TRUE,m->modelViewMat); if( m->material==Mesh::Normal || m->material==Mesh::Bump || m->material==Mesh::Parallax) { if(GeometryVao *gv=geometryVaoManager->get(m->geometry,m->vao)) { glBindVertexArray(gv->getVao()); if(GeometryDraw *d=gv->getDraw(m->draw)) { d->draw(); } } } } } }
int main () { /*--------------------------------START OPENGL--------------------------------*/ assert (restart_gl_log ()); // start GL context and O/S window using the GLFW helper library assert (start_gl ()); // set a function to be called when the mouse is clicked glfwSetMouseButtonCallback (g_window, glfw_mouse_click_callback); /*------------------------------CREATE GEOMETRY-------------------------------*/ GLfloat* vp = NULL; // array of vertex points GLfloat* vn = NULL; // array of vertex normals GLfloat* vt = NULL; // array of texture coordinates int g_point_count = 0; assert (load_obj_file (MESH_FILE, vp, vt, vn, g_point_count)); GLuint vao; glGenVertexArrays (1, &vao); glBindVertexArray (vao); GLuint points_vbo; if (NULL != vp) { glGenBuffers (1, &points_vbo); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glBufferData ( GL_ARRAY_BUFFER, 3 * g_point_count * sizeof (GLfloat), vp, GL_STATIC_DRAW ); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (0); } /*-------------------------------CREATE SHADERS-------------------------------*/ GLuint shader_programme = create_programme_from_files ( VERTEX_SHADER_FILE, FRAGMENT_SHADER_FILE ); int model_mat_location = glGetUniformLocation (shader_programme, "model"); int view_mat_location = glGetUniformLocation (shader_programme, "view"); int proj_mat_location = glGetUniformLocation (shader_programme, "proj"); int blue_location = glGetUniformLocation (shader_programme, "blue"); /*-------------------------------CREATE CAMERA--------------------------------*/ #define ONE_DEG_IN_RAD (2.0 * M_PI) / 360.0 // 0.017444444 // input variables float near = 0.1f; // clipping plane float far = 100.0f; // clipping plane float fovy = 67.0f; // 67 degrees float aspect = (float)g_gl_width / (float)g_gl_height; // aspect ratio proj_mat = perspective (fovy, aspect, near, far); float cam_speed = 3.0f; // 1 unit per second float cam_heading_speed = 50.0f; // 30 degrees per second float cam_heading = 0.0f; // y-rotation in degrees mat4 T = translate ( identity_mat4 (), vec3 (-cam_pos.v[0], -cam_pos.v[1], -cam_pos.v[2]) ); mat4 R = rotate_y_deg (identity_mat4 (), -cam_heading); versor q = quat_from_axis_deg (-cam_heading, 0.0f, 1.0f, 0.0f); view_mat = R * T; // keep track of some useful vectors that can be used for keyboard movement vec4 fwd (0.0f, 0.0f, -1.0f, 0.0f); vec4 rgt (1.0f, 0.0f, 0.0f, 0.0f); vec4 up (0.0f, 1.0f, 0.0f, 0.0f); /*---------------------------SET RENDERING DEFAULTS---------------------------*/ glUseProgram (shader_programme); glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view_mat.m); glUniformMatrix4fv (proj_mat_location, 1, GL_FALSE, proj_mat.m); // unique model matrix for each sphere mat4 model_mats[NUM_SPHERES]; for (int i = 0; i < NUM_SPHERES; i++) { model_mats[i] = translate (identity_mat4 (), sphere_pos_wor[i]); } glEnable (GL_DEPTH_TEST); // enable depth-testing glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer" glEnable (GL_CULL_FACE); // cull face glCullFace (GL_BACK); // cull back face glFrontFace (GL_CCW); // set counter-clock-wise vertex order to mean the front glClearColor (0.2, 0.2, 0.2, 1.0); // grey background to help spot mistakes glViewport (0, 0, g_gl_width, g_gl_height); /*-------------------------------RENDERING LOOP-------------------------------*/ while (!glfwWindowShouldClose (g_window)) { // update timers static double previous_seconds = glfwGetTime (); double current_seconds = glfwGetTime (); double elapsed_seconds = current_seconds - previous_seconds; previous_seconds = current_seconds; _update_fps_counter (g_window); // wipe the drawing surface clear glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram (shader_programme); glBindVertexArray (vao); for (int i = 0; i < NUM_SPHERES; i++) { if (g_selected_sphere == i) { glUniform1f (blue_location, 1.0f); } else { glUniform1f (blue_location, 0.0f); } glUniformMatrix4fv (model_mat_location, 1, GL_FALSE, model_mats[i].m); glDrawArrays (GL_TRIANGLES, 0, g_point_count); } // update other events like input handling glfwPollEvents (); // control keys bool cam_moved = false; vec3 move (0.0, 0.0, 0.0); float cam_yaw = 0.0f; // y-rotation in degrees float cam_pitch = 0.0f; float cam_roll = 0.0; if (glfwGetKey (g_window, GLFW_KEY_A)) { move.v[0] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_D)) { move.v[0] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_Q)) { move.v[1] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_E)) { move.v[1] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_W)) { move.v[2] -= cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_S)) { move.v[2] += cam_speed * elapsed_seconds; cam_moved = true; } if (glfwGetKey (g_window, GLFW_KEY_LEFT)) { cam_yaw += cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_yaw = quat_from_axis_deg ( cam_yaw, up.v[0], up.v[1], up.v[2] ); q = q_yaw * q; } if (glfwGetKey (g_window, GLFW_KEY_RIGHT)) { cam_yaw -= cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_yaw = quat_from_axis_deg ( cam_yaw, up.v[0], up.v[1], up.v[2] ); q = q_yaw * q; } if (glfwGetKey (g_window, GLFW_KEY_UP)) { cam_pitch += cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_pitch = quat_from_axis_deg ( cam_pitch, rgt.v[0], rgt.v[1], rgt.v[2] ); q = q_pitch * q; } if (glfwGetKey (g_window, GLFW_KEY_DOWN)) { cam_pitch -= cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_pitch = quat_from_axis_deg ( cam_pitch, rgt.v[0], rgt.v[1], rgt.v[2] ); q = q_pitch * q; } if (glfwGetKey (g_window, GLFW_KEY_Z)) { cam_roll -= cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_roll = quat_from_axis_deg ( cam_roll, fwd.v[0], fwd.v[1], fwd.v[2] ); q = q_roll * q; } if (glfwGetKey (g_window, GLFW_KEY_C)) { cam_roll += cam_heading_speed * elapsed_seconds; cam_moved = true; versor q_roll = quat_from_axis_deg ( cam_roll, fwd.v[0], fwd.v[1], fwd.v[2] ); q = q_roll * q; } // update view matrix if (cam_moved) { // re-calculate local axes so can move fwd in dir cam is pointing R = quat_to_mat4 (q); fwd = R * vec4 (0.0, 0.0, -1.0, 0.0); rgt = R * vec4 (1.0, 0.0, 0.0, 0.0); up = R * vec4 (0.0, 1.0, 0.0, 0.0); cam_pos = cam_pos + vec3 (fwd) * -move.v[2]; cam_pos = cam_pos + vec3 (up) * move.v[1]; cam_pos = cam_pos + vec3 (rgt) * move.v[0]; mat4 T = translate (identity_mat4 (), vec3 (cam_pos)); view_mat = inverse (R) * inverse (T); glUniformMatrix4fv (view_mat_location, 1, GL_FALSE, view_mat.m); } if (GLFW_PRESS == glfwGetKey (g_window, GLFW_KEY_ESCAPE)) { glfwSetWindowShouldClose (g_window, 1); } // put the stuff we've been drawing onto the display glfwSwapBuffers (g_window); } // close GL context and any other GLFW resources glfwTerminate(); return 0; }
void GPU_select_begin(unsigned int *buffer, unsigned int bufsize, rctf *input, char mode, int oldhits) { g_query_state.select_is_active = true; g_query_state.query_issued = false; g_query_state.active_query = 0; g_query_state.use_gpu_select = GPU_select_query_check_active(); g_query_state.num_of_queries = 0; g_query_state.bufsize = bufsize; g_query_state.buffer = buffer; g_query_state.mode = mode; g_query_state.index = 0; g_query_state.oldhits = oldhits; if (!g_query_state.use_gpu_select) { glSelectBuffer(bufsize, (GLuint *)buffer); glRenderMode(GL_SELECT); glInitNames(); glPushName(-1); } else { float viewport[4]; g_query_state.num_of_queries = ALLOC_QUERIES; g_query_state.queries = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.queries), "gpu selection queries"); g_query_state.id = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.id), "gpu selection ids"); glGenQueries(g_query_state.num_of_queries, g_query_state.queries); glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_VIEWPORT_BIT); /* disable writing to the framebuffer */ glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); /* In order to save some fill rate we minimize the viewport using rect. * We need to get the region of the scissor so that our geometry doesn't * get rejected before the depth test. Should probably cull rect against * scissor for viewport but this is a rare case I think */ glGetFloatv(GL_SCISSOR_BOX, viewport); if (!input || input->xmin == input->xmax) { glViewport(viewport[0], viewport[1], 24, 24); } else { glViewport(viewport[0], viewport[1], (int)(input->xmax - input->xmin), (int)(input->ymax - input->ymin)); } /* occlusion queries operates on fragments that pass tests and since we are interested on all * objects in the view frustum independently of their order, we need to disable the depth test */ if (mode == GPU_SELECT_ALL) { glDisable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); } else if (mode == GPU_SELECT_NEAREST_FIRST_PASS) { glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); } else if (mode == GPU_SELECT_NEAREST_SECOND_PASS) { glEnable(GL_DEPTH_TEST); glDepthMask(GL_FALSE); glDepthFunc(GL_EQUAL); } } }