void Framebuffer::Initialize( void ) { // Don't attempt to reload if we've already tried to (unless we use Clear first). if( FramebufferHandle || Texture || Depthbuffer ) return; // If framebuffers are disabled, create a blank 2x2 texture instead. if( ! Raptor::Game->Cfg.SettingAsBool( "g_framebuffers", true ) ) { glGenTextures( 1, &Texture ); glBindTexture( GL_TEXTURE_2D, Texture ); glEnable( GL_TEXTURE_2D ); unsigned char raw[ 16 ] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, raw ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TextureFilter ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glBindTexture( GL_TEXTURE_2D, 0 ); LoadedTime.Reset(); return; } // Some systems require power-of-two dimensions. if( ForcePowerOfTwo ) { AllocW = Num::NextPowerOfTwo(W); AllocH = Num::NextPowerOfTwo(H); } else { AllocW = W; AllocH = H; } // Limit framebuffers to maximum texture resolution. GLint tex_max = Raptor::Game->Cfg.SettingAsInt( "g_texture_maxres", 0 ); if( ! tex_max ) glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tex_max ); if( tex_max > 0 ) { if( ForcePowerOfTwo ) { int tex_max_pow2 = Num::NextPowerOfTwo(tex_max); tex_max = (tex_max_pow2 > tex_max) ? (tex_max_pow2 / 2) : tex_max_pow2; } if( AllocW > tex_max ) AllocW = tex_max; if( AllocH > tex_max ) AllocH = tex_max; } // Framebuffer glGenFramebuffers( 1, &FramebufferHandle ); glBindFramebuffer( GL_FRAMEBUFFER, FramebufferHandle ); // Renderbuffer glGenTextures( 1, &Texture ); glBindTexture( GL_TEXTURE_2D, Texture ); void *raw = malloc( AllocW * AllocH * 4 ); memset( raw, 0, AllocW * AllocH * 4 ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, AllocW, AllocH, 0, GL_RGBA, GL_UNSIGNED_BYTE, raw ); free( raw ); raw = NULL; glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TextureFilter ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Texture, 0 ); GLenum draw_buffers[ 1 ] = { GL_COLOR_ATTACHMENT0 }; glDrawBuffers( 1, draw_buffers ); // Depthbuffer glGenRenderbuffers( 1, &Depthbuffer ); glBindRenderbuffer( GL_RENDERBUFFER, Depthbuffer ); glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, AllocW, AllocH ); glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, Depthbuffer ); // Make sure everything worked. GLenum framebuffer_status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if( framebuffer_status == GL_FRAMEBUFFER_COMPLETE ) Initialized = true; #ifdef GL_FRAMEBUFFER_UNSUPPORTED else if( (framebuffer_status == GL_FRAMEBUFFER_UNSUPPORTED) && ! ForcePowerOfTwo ) { ForcePowerOfTwo = true; Clear(); Reload(); } #endif else { std::string status_string = "UNKNOWN ERROR"; if( framebuffer_status == GL_INVALID_ENUM ) status_string = "GL_INVALID_ENUM"; #ifdef GL_FRAMEBUFFER_UNDEFINED else if( framebuffer_status == GL_FRAMEBUFFER_UNDEFINED ) status_string = "GL_FRAMEBUFFER_UNDEFINED"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"; #endif #ifdef GL_FRAMEBUFFER_UNSUPPORTED else if( framebuffer_status == GL_FRAMEBUFFER_UNSUPPORTED ) status_string = "GL_FRAMEBUFFER_UNSUPPORTED"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; #endif #ifdef GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS ) status_string = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; #endif else status_string = std::string("0x") + Num::ToHexString( framebuffer_status ); Raptor::Game->Console.Print( std::string("Framebuffer::Initialize: OpenGL Error ") + status_string, TextConsole::MSG_ERROR ); } // Unbind things so we don't accidentally use them when we don't mean to. glBindTexture( GL_TEXTURE_2D, 0 ); glBindFramebuffer( GL_FRAMEBUFFER, 0 ); LoadedTime.Reset(); }
///////////// // main // ////////////// void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // mglStrokeText( string, x, y, scalex, scaley, linewidth, color, rotation ) if ( nrhs<3 ) return; // Set character string variable // Set scale // Set starting position int buflen=mxGetN( prhs[0] )*mxGetM( prhs[0] )+1; char * inputString=(char*) malloc(buflen); mxGetString( prhs[0], inputString, buflen); float x,y,scaleX,scaleY; float linewidth,rot; float color[3]; x=(float) *mxGetPr( prhs[1] ); y=(float) *mxGetPr( prhs[2] ); if (nrhs>3) scaleX=(float) *mxGetPr( prhs[3] ); else scaleX=1.0; if (nrhs>4) scaleY=(float) *mxGetPr( prhs[4] ); else scaleY=scaleX; if (nrhs>5) linewidth=(float) *mxGetPr( prhs[5] ); else linewidth=1; if (nrhs>6) { color[0]=(float)*mxGetPr( prhs[6] ); color[1]=(float)*(mxGetPr( prhs[6] )+1); color[2]=(float)*(mxGetPr( prhs[6] )+2); } else { color[0]=1.0; color[1]=1.0; color[2]=1.0; } if (nrhs>7) rot=(float) *mxGetPr( prhs[7] ); else rot=0.0; glLineWidth(linewidth); int rectWidth=0; GLint range[2]; glGetIntegerv(GL_POINT_SIZE_RANGE,range); if (range[1]<linewidth) { rectWidth=linewidth+1; } else { glPointSize(linewidth+1); } char space[]=" "; int iS,iC,numstrokes; float * strokesX; float * strokesY; glColor3f(color[0],color[1],color[2]); glEnable(GL_LINE_SMOOTH); bool charFound; // Select each character in string for (iS=0; iS<buflen-1; iS++) { // note that buflen includes null \0 character which we ignore iC=0; charFound=false; if (inputString[iS]==(*space)) { // advance x x+=(scaleX*1.1); continue; } else { // Find index of corresponding character for (iC=0; iC<MGLNUMCHARS; iC++) { if (inputString[iS]==MGLChars[iC]) { // mexPrintf("%c %c\n",inputString[iS],MGLChars[iC]); numstrokes=MGLCharNumStrokes[iC]; strokesX=MGLCharStrokesX[iC]; strokesY=MGLCharStrokesY[iC]; // Draw character // mexPrintf("%i %i\n",iC, iS); drawStrokeCharacter( x, y, strokesX, strokesY, scaleX, scaleY, numstrokes, MGLCharsWithDots[iC], rot, rectWidth ); // Update x,y x+=(scaleX*1.1); // letter spacing charFound=true; break; } } if (!charFound) { // draw hash iC=33; numstrokes=MGLCharNumStrokes[iC]; strokesX=MGLCharStrokesX[iC]; strokesY=MGLCharStrokesY[iC]; // Draw character // mexPrintf("%i %i\n",iC, iS); drawStrokeCharacter( x, y, strokesX, strokesY, scaleX, scaleY, numstrokes, MGLCharsWithDots[iC], rot, rectWidth ); // Update x,y x+=(scaleX*1.1); // letter spacing } } } if (nlhs==2) { plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); *mxGetPr(plhs[0]) = x; *mxGetPr(plhs[1]) = y; } }
int main(int argc, const char * argv[]) { if(!glfwInit()){ return -1; } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); auto window = glfwCreateWindow(WIDTH, HEIGHT, "Transformation", nullptr, nullptr); if (nullptr == window) { std::cout << "Failed to create GLFW windows" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); int actualWidth; int actualHeight; glfwGetFramebufferSize(window, &actualWidth, &actualHeight); glViewport(0, 0, actualWidth, actualHeight); glfwSetKeyCallback(window, key_callback); GLint nrAttributes; glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes); std::cout << "Maximum number of vertex attributes supported: " << nrAttributes << std::endl; GLuint shaderProgram = createShaderProgramWithFilenames("vertex.vsh", "fragment.fsh"); GLfloat vertices[] = { // Positions // Colors // Texture Coords 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.f, 1.0f, // Top Right 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.f, // Bottom Right -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.f, 0.f, // Bottom Left -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.f, 1.f // Top Left }; GLuint indices[] = { // Note that we start from 0! 0, 1, 3, // First Triangle 1, 2, 3 // Second Triangle }; GLuint VAO; glGenVertexArrays(1, &VAO); glBindVertexArray(VAO); GLuint VBO; glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLuint EBO; glGenBuffers(1, &EBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); int width, height; unsigned char* image = SOIL_load_image("container.jpg", &width, &height, 0, SOIL_LOAD_RGB); GLuint texture; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, 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_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image); glBindTexture(GL_TEXTURE_2D, 0); unsigned char* image2 = SOIL_load_image("awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB); GLuint texture2; glGenTextures(1, &texture2); glBindTexture(GL_TEXTURE_2D, texture2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image2); glGenerateMipmap(GL_TEXTURE_2D); SOIL_free_image_data(image2); glBindTexture(GL_TEXTURE_2D, 0); // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); while (!glfwWindowShouldClose(window)) { glfwPollEvents(); //do rendering glClearColor(0.2, 0.3, 0.3, 1.0); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(shaderProgram); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, texture); glUniform1i(glGetUniformLocation(shaderProgram, "ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); glUniform1i(glGetUniformLocation(shaderProgram, "ourTexture2"), 1); glUniform1f(glGetUniformLocation(shaderProgram, "mixValue"), mixValue); glm::mat4 trans; trans = glm::translate(trans, glm::vec3(0.5f, -0.5f, 0.0f)); trans = glm::rotate(trans, glm::radians((GLfloat)glfwGetTime() * 50.0f), glm::vec3(0.0f, 0.0f, 1.0f)); GLuint transformLoc = glGetUniformLocation(shaderProgram, "transforms"); glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans)); //draw the first triangles glBindVertexArray(VAO); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); trans = glm::mat4(); //reset the previous matrix trans = glm::translate(trans, glm::vec3(-0.5f, 0.5f, 0.0f)); float scaleFactor = sinf((GLfloat)glfwGetTime()) ; trans = glm::scale(trans,glm::vec3(scaleFactor, scaleFactor, 1.0f )); glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans)); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glfwSwapBuffers(window); } glDeleteVertexArrays(1, &VAO); glDeleteBuffers(1, &VBO); glDeleteBuffers(1, &EBO); glDeleteProgram(shaderProgram); glfwTerminate(); return 0; }
void _glGetIntegerv( int pname,Array<int> params,int offset ) { glGetIntegerv( pname,¶ms[offset] ); }
int PTex :: Set(const unsigned char *buf,int width, int height,GLint format) { if( ! buf ) { ERROR("PTex::Set: Null pointer buf"); return -1; } //sprawdzamy czy nie jest wiekszy niz na to pozwala OpenGL int max_size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size); if( (width > max_size) || (height > max_size) ) { ERROR("Image size exceeds max texture size, which is "+toString(max_size)+" pixels for each side"); return -2; } glGenTextures( 1, &texnum ); texbinded = true; glBindTexture( GL_TEXTURE_2D, texnum ); // 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_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); // glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER ); // glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER ); switch( ic_filtering ) { case FM_NEAREST: glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); break; case FM_LINEAR: glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); break; case FM_BILINEAR: glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); break; default: glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); break; } /* gluBuild2DMipmapLevels( GL_TEXTURE_2D, GL_RGBA, image->w, image->h, GL_RGBA, GL_UNSIGNED_BYTE, 0, //mipmap image level 0, //mipmap base level 0, //mipmap max level image->pixels ); */ glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, buf); glHint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);//GL_FASTEST); glGenerateMipmap(GL_TEXTURE_2D); img_w = width; img_h = height; GLint par; glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &par); w = par; glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &par); h = par; return 1; }
bool ImGui_ImplSdlGL3_CreateDeviceObjects() { // Backup GL state GLint last_texture, last_array_buffer, last_vertex_array; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer); glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array); const GLchar *vertex_shader = "#version 330\n" "uniform mat4 ProjMtx;\n" "in vec2 Position;\n" "in vec2 UV;\n" "in vec4 Color;\n" "out vec2 Frag_UV;\n" "out vec4 Frag_Color;\n" "void main()\n" "{\n" " Frag_UV = UV;\n" " Frag_Color = Color;\n" " gl_Position = ProjMtx * vec4(Position.xy,0,1);\n" "}\n"; const GLchar* fragment_shader = "#version 330\n" "uniform sampler2D Texture;\n" "in vec2 Frag_UV;\n" "in vec4 Frag_Color;\n" "out vec4 Out_Color;\n" "void main()\n" "{\n" " Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n" "}\n"; g_ShaderHandle = glCreateProgram(); g_VertHandle = glCreateShader(GL_VERTEX_SHADER); g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(g_VertHandle, 1, &vertex_shader, 0); glShaderSource(g_FragHandle, 1, &fragment_shader, 0); glCompileShader(g_VertHandle); glCompileShader(g_FragHandle); glAttachShader(g_ShaderHandle, g_VertHandle); glAttachShader(g_ShaderHandle, g_FragHandle); glLinkProgram(g_ShaderHandle); g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture"); g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx"); g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position"); g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV"); g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color"); glGenBuffers(1, &g_VboHandle); glGenBuffers(1, &g_ElementsHandle); glGenVertexArrays(1, &g_VaoHandle); glBindVertexArray(g_VaoHandle); glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); glEnableVertexAttribArray(g_AttribLocationPosition); glEnableVertexAttribArray(g_AttribLocationUV); glEnableVertexAttribArray(g_AttribLocationColor); #define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT)) glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos)); glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv)); glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col)); #undef OFFSETOF ImGui_ImplSdlGL3_CreateFontsTexture(); // Restore modified GL state glBindTexture(GL_TEXTURE_2D, last_texture); glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer); glBindVertexArray(last_vertex_array); return true; }
void Mouse::update(float dt) { memcpy(m_lastButtonState, m_buttonState, sizeof(bool) * 2); #ifdef _WIN32 m_buttonState[0] = (GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? true : false; m_buttonState[1] = (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ? true : false; #elif defined __APPLE__ #ifndef MARBLE_IOS_BUILD Uint8 mouseState = SDL_GetMouseState(NULL, NULL); m_buttonState[0] = (mouseState & SDL_BUTTON(SDL_BUTTON_LEFT)) ? true : false; m_buttonState[1] = (mouseState & SDL_BUTTON(SDL_BUTTON_RIGHT)) ? true : false; #endif #endif /* This next section of code allows for really smooth mouse movement no matter what the frame rate (well... within reason). The last 10 positions are stored in a list. Each frame a new relative position is added and the oldest is removed. These positions are then added together using a weighting value. The most recent position has the most weight, whereas the oldest as the lowest weighting. This value is then averaged to produce the new relative mouse position. */ elapsed_time += dt; if (elapsed_time > timestep_threshold) { static std::list<std::pair<float, float> > mousePositionHistory; if (m_mouseLocked) { int x, y; getMousePos(x, y); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); if ( !firstFrame ) { //Add the current mouse position - starting position mousePositionHistory.push_front(std::make_pair((float)x - (viewport[2] / 2), (float)y - (viewport[3] / 2))); if (mousePositionHistory.size() > 10) { //Make sure only the last 10 positions are stored mousePositionHistory.pop_back(); } m_relativeMousePosX = 0.0f; m_relativeMousePosY = 0.0f; float weight = 1.0f; //Calculate a weighted average for (std::list<std::pair<float, float> >::iterator i = mousePositionHistory.begin(); i != mousePositionHistory.end(); ++i) { m_relativeMousePosX += (*i).first * weight; m_relativeMousePosY += (*i).second * weight; weight *= 0.5f; } m_relativeMousePosX /= 10.0f; m_relativeMousePosY /= 10.0f; } firstFrame = false; //Put the mouse in the middle of the screen setMousePos(viewport[2] / 2, viewport[3] / 2); showCursor(false); } elapsed_time = 0.0f; } }
void processFn(struct fnargs* args) { switch (args->fn) { case glfnUNDEFINED: abort(); // bad glfn break; case glfnActiveTexture: glActiveTexture((GLenum)args->a0); break; case glfnAttachShader: glAttachShader((GLint)args->a0, (GLint)args->a1); break; case glfnBindAttribLocation: glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2); free((void*)args->a2); break; case glfnBindBuffer: glBindBuffer((GLenum)args->a0, (GLuint)args->a1); break; case glfnBindFramebuffer: glBindFramebuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindRenderbuffer: glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindTexture: glBindTexture((GLenum)args->a0, (GLint)args->a1); break; case glfnBlendColor: glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnBlendEquation: glBlendEquation((GLenum)args->a0); break; case glfnBlendEquationSeparate: glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFunc: glBlendFunc((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFuncSeparate: glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnBufferData: glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3); break; case glfnBufferSubData: glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3); break; case glfnCheckFramebufferStatus: ret = glCheckFramebufferStatus((GLenum)args->a0); break; case glfnClear: glClear((GLenum)args->a0); break; case glfnClearColor: glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnClearDepthf: glClearDepthf(*(GLfloat*)&args->a0); break; case glfnClearStencil: glClearStencil((GLint)args->a0); break; case glfnColorMask: glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3); break; case glfnCompileShader: glCompileShader((GLint)args->a0); break; case glfnCompressedTexImage2D: glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7); break; case glfnCompressedTexSubImage2D: glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8); break; case glfnCopyTexImage2D: glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCopyTexSubImage2D: glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCreateProgram: ret = glCreateProgram(); break; case glfnCreateShader: ret = glCreateShader((GLenum)args->a0); break; case glfnCullFace: glCullFace((GLenum)args->a0); break; case glfnDeleteBuffer: glDeleteBuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteFramebuffer: glDeleteFramebuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteProgram: glDeleteProgram((GLint)args->a0); break; case glfnDeleteRenderbuffer: glDeleteRenderbuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteShader: glDeleteShader((GLint)args->a0); break; case glfnDeleteTexture: glDeleteTextures(1, (const GLuint*)(&args->a0)); break; case glfnDepthFunc: glDepthFunc((GLenum)args->a0); break; case glfnDepthMask: glDepthMask((GLboolean)args->a0); break; case glfnDepthRangef: glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnDetachShader: glDetachShader((GLint)args->a0, (GLint)args->a1); break; case glfnDisable: glDisable((GLenum)args->a0); break; case glfnDisableVertexAttribArray: glDisableVertexAttribArray((GLint)args->a0); break; case glfnDrawArrays: glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnDrawElements: glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3); break; case glfnEnable: glEnable((GLenum)args->a0); break; case glfnEnableVertexAttribArray: glEnableVertexAttribArray((GLint)args->a0); break; case glfnFinish: glFinish(); break; case glfnFlush: glFlush(); break; case glfnFramebufferRenderbuffer: glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3); break; case glfnFramebufferTexture2D: glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnFrontFace: glFrontFace((GLenum)args->a0); break; case glfnGenBuffer: glGenBuffers(1, (GLuint*)&ret); break; case glfnGenFramebuffer: glGenFramebuffers(1, (GLuint*)&ret); break; case glfnGenRenderbuffer: glGenRenderbuffers(1, (GLuint*)&ret); break; case glfnGenTexture: glGenTextures(1, (GLuint*)&ret); break; case glfnGenerateMipmap: glGenerateMipmap((GLenum)args->a0); break; case glfnGetActiveAttrib: glGetActiveAttrib( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetActiveUniform: glGetActiveUniform( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetAttachedShaders: glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3); break; case glfnGetAttribLocation: ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetBooleanv: glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1); break; case glfnGetBufferParameteri: glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetFloatv: glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1); break; case glfnGetIntegerv: glGetIntegerv((GLenum)args->a0, (GLint*)args->a1); break; case glfnGetError: ret = glGetError(); break; case glfnGetFramebufferAttachmentParameteriv: glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret); break; case glfnGetProgramiv: glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetProgramInfoLog: glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetRenderbufferParameteriv: glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderiv: glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderInfoLog: glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetShaderPrecisionFormat: glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3); break; case glfnGetShaderSource: glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetString: ret = (uintptr_t)glGetString((GLenum)args->a0); break; case glfnGetTexParameterfv: glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetTexParameteriv: glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnGetUniformfv: glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2); break; case glfnGetUniformiv: glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2); break; case glfnGetUniformLocation: ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetVertexAttribfv: glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetVertexAttribiv: glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnHint: glHint((GLenum)args->a0, (GLenum)args->a1); break; case glfnIsBuffer: ret = glIsBuffer((GLint)args->a0); break; case glfnIsEnabled: ret = glIsEnabled((GLenum)args->a0); break; case glfnIsFramebuffer: ret = glIsFramebuffer((GLint)args->a0); break; case glfnIsProgram: ret = glIsProgram((GLint)args->a0); break; case glfnIsRenderbuffer: ret = glIsRenderbuffer((GLint)args->a0); break; case glfnIsShader: ret = glIsShader((GLint)args->a0); break; case glfnIsTexture: ret = glIsTexture((GLint)args->a0); break; case glfnLineWidth: glLineWidth(*(GLfloat*)&args->a0); break; case glfnLinkProgram: glLinkProgram((GLint)args->a0); break; case glfnPixelStorei: glPixelStorei((GLenum)args->a0, (GLint)args->a1); break; case glfnPolygonOffset: glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnReadPixels: glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6); break; case glfnReleaseShaderCompiler: glReleaseShaderCompiler(); break; case glfnRenderbufferStorage: glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnSampleCoverage: glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1); break; case glfnScissor: glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnShaderSource: #if defined(os_ios) || defined(os_osx) glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL); #else glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL); #endif free(*(void**)args->a2); free((void*)args->a2); break; case glfnStencilFunc: glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2); break; case glfnStencilFuncSeparate: glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3); break; case glfnStencilMask: glStencilMask((GLuint)args->a0); break; case glfnStencilMaskSeparate: glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1); break; case glfnStencilOp: glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2); break; case glfnStencilOpSeparate: glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnTexImage2D: glTexImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLsizei)args->a3, (GLsizei)args->a4, 0, // border (GLenum)args->a5, (GLenum)args->a6, (const GLvoid*)args->a7); break; case glfnTexSubImage2D: glTexSubImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLsizei)args->a4, (GLsizei)args->a5, (GLenum)args->a6, (GLenum)args->a7, (const GLvoid*)args->a8); break; case glfnTexParameterf: glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2); break; case glfnTexParameterfv: glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnTexParameteri: glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2); break; case glfnTexParameteriv: glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnUniform1f: glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnUniform1fv: glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform1i: glUniform1i((GLint)args->a0, (GLint)args->a1); break; case glfnUniform1iv: glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2f: glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnUniform2fv: glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2i: glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnUniform2iv: glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3f: glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnUniform3fv: glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3i: glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnUniform3iv: glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4f: glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnUniform4fv: glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4i: glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnUniform4iv: glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniformMatrix2fv: glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix3fv: glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix4fv: glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUseProgram: glUseProgram((GLint)args->a0); break; case glfnValidateProgram: glValidateProgram((GLint)args->a0); break; case glfnVertexAttrib1f: glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnVertexAttrib1fv: glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib2f: glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnVertexAttrib2fv: glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib3f: glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnVertexAttrib3fv: glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib4f: glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnVertexAttrib4fv: glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttribPointer: glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5); break; case glfnViewport: glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; } }
void gles2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) { glGetIntegerv(pname, params); }
static void init(const WindowInfo &window,const ContextInfo &context, const FramebufferInfo &framebuffer) { //initializam de 2 ori? if(_initialized) { std::cout<<"EROARE! GLUT - nu ma poti initializa de 2 ori, ar rezulta crash/eroare"<<std::endl; return; } //copiaza informatie pentru fereastra,context,framebuffer _context_information = context; _window_information = window; _framebuffer_information = framebuffer; //cerem glut un context OpenGL glutInitContextVersion(context.major_version, context.minor_version); glutInitContextFlags(GLUT_DEBUG); if (context.core) { glutInitContextProfile(GLUT_CORE_PROFILE); } else { glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE); } //argumente fake pentru ca nu folosim glut in linie de comanda int fakeargc = 1; char *fakeargv[] = {"fake", NULL}; glutInit(&fakeargc, fakeargv); glutInitDisplayMode(framebuffer.flags); glutInitWindowPosition(window.start_position_x, window.start_position_y); glutInitWindowSize(window.width, window.height); glutCreateWindow(window.name.c_str()); //leaga functiile locale la GLUT glutIdleFunc(_idleCallback); glutCloseFunc(_closeCallback); glutDisplayFunc(_displayCallback); glutReshapeFunc(_reshapeCallback); glutKeyboardFunc(_keyboardDownCallback); glutKeyboardUpFunc(_keyboardUpCallback); glutSpecialFunc(_specialDownCallback); glutSpecialUpFunc(_specialUpCallback); glutMotionFunc(_motionCallback); glutPassiveMotionFunc(_passiveMotionCallback); glutMouseFunc(_mouseCallback); glutMouseWheelFunc(_mouseWheelCallback); //scrie la consola diverse detalii utile const unsigned char* renderer = glGetString( GL_RENDERER ); const unsigned char* vendor = glGetString( GL_VENDOR ); const unsigned char* version = glGetString( GL_VERSION ); std::cout<<"*******************************************************************************"<<std::endl; std::cout<<"GLUT:initializare"<<std::endl; std::cout<<"GLUT:\tVendor : "<<vendor<<std::endl; std::cout<<"GLUT:\tRenderer : "<<renderer<<std::endl; std::cout<<"GLUT:\tutilizez versiunea de OpenGl : "<<version<<std::endl; std::cout<<"GLUT:\tFereasta initiala se numeste `"<<window.name<<"`, are dimensiunile ("<<window.width<<"X"<<window.height; std::cout<<") incepe de la coordonatele de ecran ("<<window.start_position_x<<"X"<<window.start_position_y; std::cout<<") si "<<((window.is_reshapable)?"este":"nu este")<<" redimensionabila"<<std::endl; std::cout<<"GLUT:\tFramebuffer initial contine buffere(duble) pentru"<<std::endl; if(glutGet(GLUT_WINDOW_RGBA)) { int r_bits, g_bits, b_bits, a_bits; glGetIntegerv(GL_RED_BITS, &r_bits); glGetIntegerv(GL_GREEN_BITS, &g_bits); glGetIntegerv(GL_BLUE_BITS, &b_bits); glGetIntegerv(GL_ALPHA_BITS, &a_bits); std::cout<<"\tCuloare R"<<r_bits<<"G"<<g_bits<<"B"<<b_bits<<"A"<<a_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_DEPTH) { int d_bits; glGetIntegerv(GL_DEPTH_BITS, &d_bits); std::cout<<"\tAdancime DEPTH"<<d_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_STENCIL) { int s_bits; glGetIntegerv(GL_STENCIL_BITS, &s_bits); std::cout<<"\tStencil STENCIL"<<s_bits<<std::endl; } if(_framebuffer_information.flags&GLUT_MULTISAMPLE) { std::cout << "\tmultisampling cu 4 sample-uri per pixel" << std::endl; } std::cout<<"GLUT:\tContextul OpenGL este "<<_context_information.major_version<<"."<<_context_information.minor_version; std::cout<<" si profilul este de "<<((_context_information.core)?"core":"compatibilitate")<<std::endl; std::cout<<"*******************************************************************************"<<std::endl; //cand glut este inchis este returnat la main pentru oportunitatea de cleanup corect glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); //am terminat cu initializarea! _initialized=true; }
bool checkCaps() { caps Caps(caps::CORE); GLint NumCompressedTextureFormats = 0; glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &NumCompressedTextureFormats); std::vector<GLint> CompressedTextureFormats(NumCompressedTextureFormats); glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, &CompressedTextureFormats[0]); if(this->checkExtension("GL_EXT_texture_compression_s3tc")) { if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_S3TC_DXT1_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) == CompressedTextureFormats.end()) return false; } if(this->checkExtension("GL_EXT_texture_sRGB") && this->checkExtension("GL_EXT_texture_compression_s3tc")) { if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_S3TC_DXT1_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT) == CompressedTextureFormats.end()) return false; } if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RED_RGTC1) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RED_RGTC1) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RG_RGTC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RG_RGTC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_BPTC_UNORM) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB8_ETC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_ETC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA8_ETC2_EAC) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_R11_EAC) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_R11_EAC) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RG11_EAC) == CompressedTextureFormats.end()) return false; if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RG11_EAC) == CompressedTextureFormats.end()) return false; return true; }
void Engine::display(bool select) { // Setup a perspective projection glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (select) { GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); gluPickMatrix(static_cast<GLdouble>(lastMouseX), static_cast<GLdouble>(viewport[3] - lastMouseY), cfg::selectTolerance, cfg::selectTolerance, viewport); } gluPerspective(90.f, app->GetWidth()/static_cast<float>(app->GetHeight()), 1.f, 10000.f); // Clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Apply some transformations glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(cameraPositionX, cameraPositionY, -cameraDistance); glRotatef(cameraRotationX, 1.f, 0.f, 0.f); glRotatef(cameraRotationY, 0.f, 1.f, 0.f); // 3D artists normally use (0,0,1) UP vector instead of (0,1,0) glRotatef(-90, 1.f, 0.f, 0.f); // Axes if (!select && drawAxes) { glDisable(GL_LIGHTING); glLineWidth(2.f); glBegin(GL_LINES); glColor3f(1.f, 0.f, 0.f); glVertex3f(0.f, 0.f, 0.f); glVertex3f(cameraDistance, 0.f, 0.f); glColor3f(0.f, 1.f, 0.f); glVertex3f(0.f, 0.f, 0.f); glVertex3f(0.f, cameraDistance, 0.f); glColor3f(0.f, 0.f, 1.f); glVertex3f(0.f, 0.f, 0.f); glVertex3f(0.f, 0.f, cameraDistance); glEnd(); glEnable(GL_LIGHTING); } // Draw model->draw(); // Finally, display rendered frame on screen if (!select) app->Display(); ++frames; if (frames >= 1000) { elapsedTime = clock->GetElapsedTime(); cout << "FPS: " << (frames/(elapsedTime-lastTime)) << endl; lastTime = elapsedTime; frames = 0; } }
GLint getInteger(GLenum token) { GLint value; glGetIntegerv(token, &value); return value; }
GLvoid NEHE22::DrawGLScene(){ if (bumps) { if (useMultitexture && maxTexelUnits>1){ doMesh2TexelUnits(); } else{ doMesh1TexelUnits(); } } else{ doMeshNoBumps(); } //draw FPS text GLint matrixMode; GLboolean lightingOn; lightingOn= glIsEnabled(GL_LIGHTING); /* lighting on? */ if (lightingOn) glDisable(GL_LIGHTING); glGetIntegerv(GL_MATRIX_MODE, &matrixMode); /* matrix mode? */ glDisable(GL_TEXTURE_2D); glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glPushAttrib(GL_COLOR_BUFFER_BIT); /* save current colour */ glTranslatef(0.0f,0.0f,-1.0f); glColor3f(0.8f,0.8f,0.8f);//set text color computeFPS(); Utils::drawText(-0.98f,-0.98f, GLUT_BITMAP_HELVETICA_12, FPSstr); glPopAttrib(); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(matrixMode); if (lightingOn) glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); // Enable Texture Mapping glEnable(GL_DEPTH_TEST); glutSwapBuffers(); // handle keyboard input if (keys['e']){ keys['e']=false; emboss=!emboss; } if (keys['m']){ keys['m']=false; useMultitexture=((!useMultitexture) && multitextureSupported); } if (keys['b']){ keys['b']=false; bumps=!bumps; } if (keys['f']){ keys['f']=false; filter++; filter%=3; } if(specialKeys[GLUT_KEY_PAGE_UP]){ z-=0.02f; } if(specialKeys[GLUT_KEY_PAGE_DOWN]){ z+=0.02f; } if (specialKeys[GLUT_KEY_UP]){ xspeed-=0.01f; } if (specialKeys[GLUT_KEY_DOWN]){ xspeed+=0.01f; } if (specialKeys[GLUT_KEY_RIGHT]){ yspeed+=0.01f; } if (specialKeys[GLUT_KEY_LEFT]){ yspeed-=0.01f; } }
/* Render::renderSceneShadowMap: shadow mapping */ void Render::renderSceneShadowMap(PMDObject *objs, const short *order, int num, Stage *stage, bool useMMDLikeCartoon, bool useCartoonRendering, float lightIntensity, const float *lightDirection, const float *lightColor, int shadowMappingTextureSize, bool shadowMappingLightFirst, float shadowMappingSelfDensity) { short i; GLint viewport[4]; /* store viewport */ GLdouble modelview[16]; /* store model view transform */ GLdouble projection[16]; /* store projection transform */ bool toonLight = true; #ifdef RENDER_SHADOWAUTOVIEW float eyeDist; btVector3 v; #endif /* RENDER_SHADOWAUTOVIEW */ static GLfloat lightdim[] = { 0.2f, 0.2f, 0.2f, 1.0f }; static const GLfloat lightblk[] = { 0.0f, 0.0f, 0.0f, 1.0f }; /* render the depth texture */ /* store the current viewport */ glGetIntegerv(GL_VIEWPORT, viewport); /* store the current projection matrix */ glGetDoublev(GL_PROJECTION_MATRIX, projection); /* switch to FBO for depth buffer rendering */ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboID); /* clear the buffer */ /* clear only the depth buffer, since other buffers will not be used */ glClear(GL_DEPTH_BUFFER_BIT); /* set the viewport to the required texture size */ glViewport(0, 0, shadowMappingTextureSize, shadowMappingTextureSize); /* reset the projection matrix */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); /* set the model view matrix to make the light position as eye point and capture the whole scene in the view */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); #ifdef RENDER_SHADOWAUTOVIEW /* set the distance to cover all the model range */ eyeDist = m_shadowMapAutoViewRadius / sinf(RENDER_SHADOWAUTOVIEWANGLE * 0.5f * 3.1415926f / 180.0f); /* set the perspective */ gluPerspective(RENDER_SHADOWAUTOVIEWANGLE, 1.0, 1.0, eyeDist + m_shadowMapAutoViewRadius + 50.0f); /* +50.0f is needed to cover the background */ /* the viewpoint should be at eyeDist far toward light direction from the model center */ v = m_lightVec * eyeDist + m_shadowMapAutoViewEyePoint; gluLookAt(v.x(), v.y(), v.z(), m_shadowMapAutoViewEyePoint.x(), m_shadowMapAutoViewEyePoint.y(), m_shadowMapAutoViewEyePoint.z(), 0.0, 1.0, 0.0); #else /* fixed view */ gluPerspective(25.0, 1.0, 1.0, 120.0); gluLookAt(30.0, 77.0, 30.0, 0.0, 17.0, 0.0, 0.0, 1.0, 0.0); #endif /* RENDER_SHADOWAUTOVIEW */ /* keep the current model view for later process */ glGetDoublev(GL_MODELVIEW_MATRIX, modelview); /* do not write into frame buffer other than depth information */ glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); /* also, lighting is not needed */ glDisable(GL_LIGHTING); /* disable rendering the front surface to get the depth of back face */ glCullFace(GL_FRONT); /* disable alpha test */ glDisable(GL_ALPHA_TEST); /* we are now writing to depth texture using FBO, so disable the depth texture mapping here */ glActiveTextureARB(GL_TEXTURE3_ARB); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); /* set polygon offset to avoid "moire" */ glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(4.0, 4.0); /* render objects for depth */ /* only objects that wants to drop shadow should be rendered here */ for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true) { objs[order[i]].getPMDModel()->renderForShadow(); } } /* reset the polygon offset */ glDisable(GL_POLYGON_OFFSET_FILL); /* switch to default FBO */ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); /* revert configurations to normal rendering */ glViewport(viewport[0], viewport[1], viewport[2], viewport[3]); glMatrixMode(GL_PROJECTION); glLoadMatrixd(projection); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glEnable(GL_LIGHTING); glCullFace(GL_BACK); glEnable(GL_ALPHA_TEST); /* clear all the buffers */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); /* render the full scene */ /* set model view matrix, as the same as normal rendering */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixf(m_rotMatrix); /* render the whole scene */ if (shadowMappingLightFirst) { /* render light setting, later render only the shadow part with dark setting */ stage->renderBackground(); stage->renderFloor(); for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true) { if (objs[order[i]].getPMDModel()->getToonFlag() == false && toonLight == true) { /* disable toon lighting */ updateLight(true, false, lightIntensity, lightDirection, lightColor); toonLight = false; } else if (objs[order[i]].getPMDModel()->getToonFlag() == true && toonLight == false) { /* enable toon lighting */ updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); toonLight = true; } objs[order[i]].getPMDModel()->renderModel(); objs[order[i]].getPMDModel()->renderEdge(); } } if (toonLight == false) { /* restore toon lighting */ updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); } } else { /* render in dark setting, later render only the non-shadow part with light setting */ /* light setting for non-toon objects */ lightdim[0] = lightdim[1] = lightdim[2] = 0.55f - 0.2f * shadowMappingSelfDensity; glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdim); glLightfv(GL_LIGHT0, GL_AMBIENT, lightdim); glLightfv(GL_LIGHT0, GL_SPECULAR, lightblk); /* render the non-toon objects (back, floor, non-toon models) */ stage->renderBackground(); stage->renderFloor(); for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == false) objs[order[i]].getPMDModel()->renderModel(); } /* for toon objects, they should apply the model-defined toon texture color at texture coordinates (0, 0) for shadow rendering */ /* so restore the light setting */ if (useCartoonRendering == true) updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); /* render the toon objects */ for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == true) { /* set texture coordinates for shadow mapping */ objs[order[i]].getPMDModel()->updateShadowColorTexCoord(shadowMappingSelfDensity); /* tell model to render with the shadow corrdinates */ objs[order[i]].getPMDModel()->setSelfShadowDrawing(true); /* render model and edge */ objs[order[i]].getPMDModel()->renderModel(); objs[order[i]].getPMDModel()->renderEdge(); /* disable shadow rendering */ objs[order[i]].getPMDModel()->setSelfShadowDrawing(false); } } if (useCartoonRendering == false) updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); } /* render the part clipped by the depth texture */ /* activate the texture unit for shadow mapping and make it current */ glActiveTextureARB(GL_TEXTURE3_ARB); /* set texture matrix (note: matrices should be set in reverse order) */ glMatrixMode(GL_TEXTURE); glLoadIdentity(); /* move the range from [-1,1] to [0,1] */ glTranslated(0.5, 0.5, 0.5); glScaled(0.5, 0.5, 0.5); /* multiply the model view matrix when the depth texture was rendered */ glMultMatrixd(modelview); /* multiply the inverse matrix of current model view matrix */ glMultMatrixf(m_rotMatrixInv); /* revert to model view matrix mode */ glMatrixMode(GL_MODELVIEW); /* enable texture mapping with texture coordinate generation */ glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glEnable(GL_TEXTURE_GEN_R); glEnable(GL_TEXTURE_GEN_Q); /* bind the depth texture rendered at the first step */ glBindTexture(GL_TEXTURE_2D, m_depthTextureID); /* depth texture set up was done, now switch current texture unit to default */ glActiveTextureARB(GL_TEXTURE0_ARB); /* set depth func to allow overwrite for the same surface in the following rendering */ glDepthFunc(GL_LEQUAL); if (shadowMappingLightFirst) { /* the area clipped by depth texture by alpha test is dark part */ glAlphaFunc(GL_GEQUAL, 0.1f); /* light setting for non-toon objects */ lightdim[0] = lightdim[1] = lightdim[2] = 0.55f - 0.2f * shadowMappingSelfDensity; glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdim); glLightfv(GL_LIGHT0, GL_AMBIENT, lightdim); glLightfv(GL_LIGHT0, GL_SPECULAR, lightblk); /* render the non-toon objects (back, floor, non-toon models) */ stage->renderBackground(); stage->renderFloor(); for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == false) objs[order[i]].getPMDModel()->renderModel(); } /* for toon objects, they should apply the model-defined toon texture color at texture coordinates (0, 0) for shadow rendering */ /* so restore the light setting */ if (useCartoonRendering == true) updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); /* render the toon objects */ for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == true) { /* set texture coordinates for shadow mapping */ objs[order[i]].getPMDModel()->updateShadowColorTexCoord(shadowMappingSelfDensity); /* tell model to render with the shadow corrdinates */ objs[order[i]].getPMDModel()->setSelfShadowDrawing(true); /* render model and edge */ objs[order[i]].getPMDModel()->renderModel(); /* disable shadow rendering */ objs[order[i]].getPMDModel()->setSelfShadowDrawing(false); } } if (useCartoonRendering == false) updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); } else { /* the area clipped by depth texture by alpha test is light part */ glAlphaFunc(GL_GEQUAL, 0.001f); stage->renderBackground(); stage->renderFloor(); for (i = 0; i < num; i++) { if (objs[order[i]].isEnable() == true) { if (objs[order[i]].getPMDModel()->getToonFlag() == false && toonLight == true) { /* disable toon lighting */ updateLight(true, false, lightIntensity, lightDirection, lightColor); toonLight = false; } else if (objs[order[i]].getPMDModel()->getToonFlag() == true && toonLight == false) { /* enable toon lighting */ updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); toonLight = true; } objs[order[i]].getPMDModel()->renderModel(); } } if (toonLight == false) { /* restore toon lighting */ updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor); } } /* reset settings */ glDepthFunc(GL_LESS); glAlphaFunc(GL_GEQUAL, 0.05f); glActiveTextureARB(GL_TEXTURE3_ARB); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glDisable(GL_TEXTURE_GEN_R); glDisable(GL_TEXTURE_GEN_Q); glDisable(GL_TEXTURE_2D); glActiveTextureARB(GL_TEXTURE0_ARB); }
void GFXGLDevice::enumerateAdapters( Vector<GFXAdapter*> &adapterList ) { AssertFatal( SDL_WasInit(SDL_INIT_VIDEO), ""); PlatformGL::init(); // for hints about context creation // Create a dummy window & openGL context so that gl functions can be used here SDL_Window* tempWindow = SDL_CreateWindow( "", // window title SDL_WINDOWPOS_UNDEFINED, // initial x position SDL_WINDOWPOS_UNDEFINED, // initial y position 640, // width, in pixels 480, // height, in pixels SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN // flags - see below ); SDL_ClearError(); SDL_GLContext tempContext = SDL_GL_CreateContext( tempWindow ); if( !tempContext ) { const char *err = SDL_GetError(); Con::printf( err ); AssertFatal(0, err ); return; } SDL_ClearError(); SDL_GL_MakeCurrent( tempWindow, tempContext ); const char *err = SDL_GetError(); if( err && err[0] ) { Con::printf( err ); AssertFatal(0, err ); } //check minimun Opengl 3.2 int major, minor; glGetIntegerv(GL_MAJOR_VERSION, &major); glGetIntegerv(GL_MINOR_VERSION, &minor); if( major < 3 || ( major == 3 && minor < 2 ) ) { Con::errorf("GFXGLDevice: Error! Need OpenGL 3.2 at least, have %i.%i.", major, minor); return; } loadGLCore(); GFXAdapter *toAdd = new GFXAdapter; toAdd->mIndex = 0; const char* renderer = (const char*) glGetString( GL_RENDERER ); AssertFatal( renderer != NULL, "GL_RENDERER returned NULL!" ); if (renderer) { dStrcpy(toAdd->mName, renderer); dStrncat(toAdd->mName, " OpenGL", GFXAdapter::MaxAdapterNameLen); } else dStrcpy(toAdd->mName, "OpenGL"); toAdd->mType = OpenGL; toAdd->mShaderModel = 0.f; toAdd->mCreateDeviceInstanceDelegate = mCreateDeviceInstance; // Enumerate all available resolutions: EnumerateVideoModes(toAdd->mAvailableModes); // Add to the list of available adapters. adapterList.push_back(toAdd); // Cleanup window & open gl context SDL_DestroyWindow( tempWindow ); SDL_GL_DeleteContext( tempContext ); }
/* Render::pickModel: pick up a model at the screen position */ int Render::pickModel(PMDObject *objs, int num, int x, int y, int *allowDropPicked) { int i; GLuint selectionBuffer[512]; GLint viewport[4]; GLint hits; GLuint *data; GLuint minDepth = 0, minDepthAllowDrop = 0; int minID, minIDAllowDrop; GLuint depth; int id; /* get current viewport */ glGetIntegerv(GL_VIEWPORT, viewport); /* set selection buffer */ glSelectBuffer(512, selectionBuffer); /* begin selection mode */ glRenderMode(GL_SELECT); /* save projection matrix */ glMatrixMode(GL_PROJECTION); glPushMatrix(); /* set projection matrix for picking */ glLoadIdentity(); /* apply picking matrix */ gluPickMatrix(x, viewport[3] - y, 15.0, 15.0, viewport); /* apply normal projection matrix */ applyProjectionMatrix(); /* switch to model view mode */ glMatrixMode(GL_MODELVIEW); /* initialize name buffer */ glInitNames(); glPushName(0); /* draw models with selection names */ for (i = 0; i < num; i++) { if (objs[i].isEnable() == true) { glLoadName(i); objs[i].getPMDModel()->renderForPick(); } } /* restore projection matrix */ glMatrixMode(GL_PROJECTION); glPopMatrix(); /* switch to model view mode */ glMatrixMode(GL_MODELVIEW); /* end selection mode and get number of hits */ hits = glRenderMode(GL_RENDER); if (hits == 0) return -1; data = &(selectionBuffer[0]); minID = -1; minIDAllowDrop = -1; for (i = 0; i < hits; i++) { depth = *(data + 1); id = *(data + 3); if (minID == -1 || minDepth > depth) { minDepth = depth; minID = id; } if (allowDropPicked && objs[id].allowMotionFileDrop()) { if (minIDAllowDrop == -1 || minDepthAllowDrop > depth) { minDepthAllowDrop = depth; minIDAllowDrop = id; } } data += *data + 3; } if (allowDropPicked) *allowDropPicked = minIDAllowDrop; return minID; }
Engine::Engine(util::Dir *data_dir, const char *windowtitle) : running(false), window_size{800, 600}, camgame_phys{10 * coord::settings::phys_per_tile, 10 * coord::settings::phys_per_tile, 0}, camgame_window{400, 300}, camhud_window{0, 600}, tile_halfsize{48, 24}, // TODO: get from convert script data_dir(data_dir), audio_manager{48000, AUDIO_S16LSB, 2, 4096} { // enqueue the engine's own input handler to the // execution list. this->register_input_action(&this->input_handler); this->input_handler.register_resize_action(this); if (SDL_Init(SDL_INIT_VIDEO) < 0) { throw util::Error("SDL video initialization: %s", SDL_GetError()); } else { log::msg("initialized SDL video subsystems."); } SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); int32_t window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_MAXIMIZED; this->window = SDL_CreateWindow( windowtitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, this->window_size.x, this->window_size.y, window_flags ); if (this->window == nullptr) { throw util::Error("Failed creating SDL window: %s", SDL_GetError()); } // load support for the PNG image formats, jpg bit: IMG_INIT_JPG int wanted_image_formats = IMG_INIT_PNG; int sdlimg_inited = IMG_Init(wanted_image_formats); if ((sdlimg_inited & wanted_image_formats) != wanted_image_formats) { throw util::Error("Failed to init PNG support: %s", IMG_GetError()); } this->glcontext = SDL_GL_CreateContext(this->window); if (this->glcontext == nullptr) { throw util::Error("Failed creating OpenGL context: %s", SDL_GetError()); } // initialize glew, for shaders n stuff GLenum glew_state = glewInit(); if (glew_state != GLEW_OK) { throw util::Error("GLEW initialization failed"); } if (!GLEW_VERSION_2_1) { throw util::Error("OpenGL 2.1 not available"); } // to quote the standard doc: // 'The value gives a rough estimate // of the largest texture that the GL can handle' // -> wat? // anyways, we need at least 1024x1024. int max_texture_size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); log::dbg("Maximum supported texture size: %d", max_texture_size); if (max_texture_size < 1024) { throw util::Error("Maximum supported texture size too small: %d", max_texture_size); } int max_texture_units; glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_texture_units); log::dbg("Maximum supported texture units: %d", max_texture_units); if (max_texture_size < 2) { throw util::Error("Your GPU has too less texture units: %d", max_texture_units); } // vsync on SDL_GL_SetSwapInterval(1); // enable alpha blending glEnable(GL_BLEND); // order of drawing relevant for depth // what gets drawn last is displayed on top. glDisable(GL_DEPTH_TEST); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // initialize debug text font this->dejavuserif20 = new Font{"DejaVu Serif", "Book", 20}; // initialize job manager with cpucount-2 worker threads int number_of_worker_threads = SDL_GetCPUCount() - 2; if (number_of_worker_threads <= 0) { number_of_worker_threads = 1; } this->job_manager = new job::JobManager{number_of_worker_threads}; // initialize audio auto devices = audio::AudioManager::get_devices(); if (devices.empty()) { throw util::Error{"No audio devices found"}; } }
Renderer::Renderer() { //the shader used for rendering models this->debug=true; this->modelShader.compileShaderFromFile("model.vsh",GLSLShader::VERTEX); this->modelShader.compileShaderFromFile("model.fsh",GLSLShader::FRAGMENT); this->modelShader.bindAttribLocation(0,"vertexPosition"); this->modelShader.bindAttribLocation(1,"vertexNormal"); this->modelShader.bindAttribLocation(2,"vertexUv"); if(debug) cout<<this->modelShader.log(); this->modelShader.link(); if(debug) cout<<this->modelShader.log(); this->modelShader.setUniform("tex1",0); //the shader used for rendering the terrain this->debug=true; //bbox this->bBoxShader.compileShaderFromFile("bbox.vsh",GLSLShader::VERTEX); this->bBoxShader.compileShaderFromFile("bbox.fsh",GLSLShader::FRAGMENT); this->bBoxShader.bindAttribLocation(3,"bBoxCordsVertex"); if(debug) cout<<this->bBoxShader.log(); this->bBoxShader.link(); if(debug) cout<<this->bBoxShader.log(); glUseProgram(0); if(debug) { //info const GLubyte *vendor = glGetString(GL_VENDOR); const GLubyte *renderer = glGetString(GL_RENDERER); const GLubyte *version = glGetString(GL_VERSION); const GLubyte *glslver = glGetString(GL_SHADING_LANGUAGE_VERSION); GLint major,minor; glGetIntegerv(GL_MAJOR_VERSION,&major); glGetIntegerv(GL_MINOR_VERSION,&minor); cout <<"vendor: "<<vendor<<endl; cout <<"renderer: "<<renderer<<endl; cout <<"openGL version: "<<version<<endl; cout <<"GLSL version: "<<glslver<<endl; cout <<"GL version, maj min: "<<major<<minor<<endl; } glEnable(GL_DEPTH_TEST); // enable depth-testing glDepthFunc(GL_LESS); // set depth-testing function type //glEnable(GL_CULL_FACE); // enable culling of back-faces //glCullFace(GL_BACK); // enable culling of back-faces //glFrontFace(GL_CCW); this->viewMatrix=mat4(0.0f); this->projMatrix=mat4(0.0f); }
void vsx_statelist::render() { if (render_first) { glewInit(); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); if (tex1.has_buffer_support()) { tex1.init_buffer(viewport[2], viewport[3]); tex_to.init_buffer(viewport[2], viewport[3]); get_files_recursive(own_path+"visuals_faders", &fader_file_list,"",".svn CVS"); for (std::list<vsx_string>::iterator it = fader_file_list.begin(); it != fader_file_list.end(); ++it) { #ifdef VSXU_DEBUG printf("initializing fader %s\n", (*it).c_str()); #endif vsx_engine* lvxe = new vsx_engine(); lvxe->dump_modules_to_disk = false; lvxe->init(sound_type); lvxe->start(); lvxe->load_state(*it); faders.push_back(lvxe); fade_id = 0; } } transitioning = false; render_first = false; if ( state_iter == statelist.end() ) return; // mark all state_info instances volatile for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++) { (*state_iter).is_volatile = true; } // go through statelist and load and validate every plugin std::vector<state_info> new_statelist; for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++) { if (init_current((*state_iter).engine, &(*state_iter)) > 0) { continue; } new_statelist.push_back(*state_iter); if (option_preload_all == true) { while ( (*state_iter).engine->modules_left_to_load ) { (*state_iter).engine->process_message_queue( &(*state_iter).cmd_in, cmd_out = &(*state_iter).cmd_out,false, true); (*state_iter).engine->render(); } } } statelist = new_statelist; // mark all state_info instances non-volatile (engine will be deleted when state_iter will be deleted) for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++) { (*state_iter).is_volatile = true; } // reset state_iter to a random state state_iter = statelist.begin(); int steps = rand() % statelist.size(); while (steps) { ++state_iter; if (state_iter == statelist.end()) state_iter = statelist.begin(); --steps; } vxe = (*state_iter).engine; cmd_in = &(*state_iter).cmd_in; cmd_out = &(*state_iter).cmd_out; } // render first // prevent from rendering by mistake if ( !statelist.size() ) return; if ((*state_iter).engine != vxe) // change is on the way { if ( tex_to.has_buffer_support() ) { tex_to.begin_capture(); if ((*state_iter).engine) { (*state_iter).engine->process_message_queue(&(*state_iter).cmd_in,&(*state_iter).cmd_out); (*state_iter).engine->render(); } glColorMask(false, false, false, true); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColorMask(true, true, true, true); tex_to.end_capture(); if ( (*state_iter).engine->modules_left_to_load == 0 && (*state_iter).engine->commands_internal.count() == 0 && transition_time > 1.0f ) { transition_time = 1.0f; timer.start(); fade_id = rand() % (faders.size()); } } else { transition_time = -1.0f; } if (transition_time <= 0.0) { vxe = (*state_iter).engine; cmd_in = &(*state_iter).cmd_in; cmd_out = &(*state_iter).cmd_out; transitioning = false; transition_time = 2.0f; if (cmd_out && cmd_in) { if (vxe) { vxe->process_message_queue(cmd_in,cmd_out); } cmd_out->clear(true); } if (vxe) { vxe->render(); } } else { if (cmd_out && cmd_in) { if (vxe) { vxe->process_message_queue(cmd_in,cmd_out); } cmd_out->clear(true); } // begin capture if (tex1.has_buffer_support()) { tex1.begin_capture(); } // render if (vxe) { vxe->render(); } glColorMask(false, false, false, true); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColorMask(true, true, true, true); // end capture and send to fader if (tex1.has_buffer_support()) { tex1.end_capture(); vsx_module_param_texture* param_t_a = (vsx_module_param_texture*)faders[fade_id]->get_in_param_by_name("visual_fader", "texture_a_in"); vsx_module_param_texture* param_t_b = (vsx_module_param_texture*)faders[fade_id]->get_in_param_by_name("visual_fader", "texture_b_in"); vsx_module_param_float* param_pos = (vsx_module_param_float*)faders[fade_id]->get_in_param_by_name("visual_fader", "fade_pos_in"); vsx_module_param_float* fade_pos_from_engine = (vsx_module_param_float*)faders[fade_id]->get_in_param_by_name("visual_fader", "fade_pos_from_engine"); faders[fade_id]->process_message_queue(&l_cmd_in, &l_cmd_out); l_cmd_out.clear(); if (param_t_a && param_t_b && param_pos && fade_pos_from_engine) { param_t_a->set(&tex1); param_t_b->set(&tex_to); fade_pos_from_engine->set(1.0f); float t = transition_time; if (t > 1.0f) t = 1.0f; if (t < 0.0f) t = 0.0f; param_pos->set(1.0-t); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); faders[fade_id]->render(); } } if (transition_time <= 1.0f) { transition_time -= timer.dtime(); } } } else { if (cmd_out && cmd_in) { vxe->process_message_queue(cmd_in, cmd_out); cmd_out->clear(); } vxe->render(); if (randomizer) { randomizer_time -= vxe->engine_info.real_dtime; if (randomizer_time < 0.0f) { random_state(); randomizer_time = (float)(rand()%1000)*0.001f*15.0f+10.0f; } } } }
/* Initialise the double buffered display */ bool screenInitialise() { GLint glMaxTUs; GLenum err; glErrors(); err = glewInit(); if (GLEW_OK != err) { debug(LOG_FATAL, "Error: %s", glewGetErrorString(err)); exit(1); } /* Dump general information about OpenGL implementation to the console and the dump file */ ssprintf(opengl.vendor, "OpenGL Vendor: %s", glGetString(GL_VENDOR)); addDumpInfo(opengl.vendor); debug(LOG_3D, "%s", opengl.vendor); ssprintf(opengl.renderer, "OpenGL Renderer: %s", glGetString(GL_RENDERER)); addDumpInfo(opengl.renderer); debug(LOG_3D, "%s", opengl.renderer); ssprintf(opengl.version, "OpenGL Version: %s", glGetString(GL_VERSION)); addDumpInfo(opengl.version); debug(LOG_3D, "%s", opengl.version); ssprintf(opengl.GLEWversion, "GLEW Version: %s", glewGetString(GLEW_VERSION)); if (strncmp(opengl.GLEWversion, "1.9.", 4) == 0) // work around known bug with KHR_debug extension support in this release { debug(LOG_WARNING, "Your version of GLEW is old and buggy, please upgrade to at least version 1.10."); khr_debug = false; } else { khr_debug = GLEW_KHR_debug; } addDumpInfo(opengl.GLEWversion); debug(LOG_3D, "%s", opengl.GLEWversion); GLubyte const *extensionsBegin = glGetString(GL_EXTENSIONS); if (extensionsBegin == nullptr) { static GLubyte const emptyString[] = ""; extensionsBegin = emptyString; } GLubyte const *extensionsEnd = extensionsBegin + strlen((char const *)extensionsBegin); std::vector<std::string> glExtensions; for (GLubyte const *i = extensionsBegin; i < extensionsEnd;) { GLubyte const *j = std::find(i, extensionsEnd, ' '); glExtensions.push_back(std::string(i, j)); i = j + 1; } /* Dump extended information about OpenGL implementation to the console */ std::string line; for (unsigned n = 0; n < glExtensions.size(); ++n) { std::string word = " "; word += glExtensions[n]; if (n + 1 != glExtensions.size()) { word += ','; } if (line.size() + word.size() > 160) { debug(LOG_3D, "OpenGL Extensions:%s", line.c_str()); line.clear(); } line += word; } debug(LOG_3D, "OpenGL Extensions:%s", line.c_str()); debug(LOG_3D, "Notable OpenGL features:"); debug(LOG_3D, " * OpenGL 1.2 %s supported!", GLEW_VERSION_1_2 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 1.3 %s supported!", GLEW_VERSION_1_3 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 1.4 %s supported!", GLEW_VERSION_1_4 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 1.5 %s supported!", GLEW_VERSION_1_5 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 2.0 %s supported!", GLEW_VERSION_2_0 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 2.1 %s supported!", GLEW_VERSION_2_1 ? "is" : "is NOT"); debug(LOG_3D, " * OpenGL 3.0 %s supported!", GLEW_VERSION_3_0 ? "is" : "is NOT"); debug(LOG_3D, " * Texture compression %s supported.", GLEW_ARB_texture_compression ? "is" : "is NOT"); debug(LOG_3D, " * Two side stencil %s supported.", GLEW_EXT_stencil_two_side ? "is" : "is NOT"); debug(LOG_3D, " * ATI separate stencil is%s supported.", GLEW_ATI_separate_stencil ? "" : " NOT"); debug(LOG_3D, " * Stencil wrap %s supported.", GLEW_EXT_stencil_wrap ? "is" : "is NOT"); debug(LOG_3D, " * Anisotropic filtering %s supported.", GLEW_EXT_texture_filter_anisotropic ? "is" : "is NOT"); debug(LOG_3D, " * Rectangular texture %s supported.", GLEW_ARB_texture_rectangle ? "is" : "is NOT"); debug(LOG_3D, " * FrameBuffer Object (FBO) %s supported.", GLEW_EXT_framebuffer_object ? "is" : "is NOT"); debug(LOG_3D, " * ARB Vertex Buffer Object (VBO) %s supported.", GLEW_ARB_vertex_buffer_object ? "is" : "is NOT"); debug(LOG_3D, " * NPOT %s supported.", GLEW_ARB_texture_non_power_of_two ? "is" : "is NOT"); debug(LOG_3D, " * texture cube_map %s supported.", GLEW_ARB_texture_cube_map ? "is" : "is NOT"); glGetIntegerv(GL_MAX_TEXTURE_UNITS, &glMaxTUs); debug(LOG_3D, " * Total number of Texture Units (TUs) supported is %d.", (int) glMaxTUs); debug(LOG_3D, " * GL_ARB_timer_query %s supported!", GLEW_ARB_timer_query ? "is" : "is NOT"); debug(LOG_3D, " * KHR_DEBUG support %s detected", khr_debug ? "was" : "was NOT"); if (!GLEW_VERSION_2_0) { debug(LOG_FATAL, "OpenGL 2.0 not supported! Please upgrade your drivers."); return false; } screenWidth = MAX(screenWidth, 640); screenHeight = MAX(screenHeight, 480); std::pair<int, int> glslVersion(0, 0); sscanf((char const *)glGetString(GL_SHADING_LANGUAGE_VERSION), "%d.%d", &glslVersion.first, &glslVersion.second); /* Dump information about OpenGL 2.0+ implementation to the console and the dump file */ GLint glMaxTIUs, glMaxTCs, glMaxTIUAs, glmaxSamples, glmaxSamplesbuf; debug(LOG_3D, " * OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); ssprintf(opengl.GLSLversion, "OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); addDumpInfo(opengl.GLSLversion); glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &glMaxTIUs); debug(LOG_3D, " * Total number of Texture Image Units (TIUs) supported is %d.", (int) glMaxTIUs); glGetIntegerv(GL_MAX_TEXTURE_COORDS, &glMaxTCs); debug(LOG_3D, " * Total number of Texture Coords (TCs) supported is %d.", (int) glMaxTCs); glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &glMaxTIUAs); debug(LOG_3D, " * Total number of Texture Image Units ARB(TIUAs) supported is %d.", (int) glMaxTIUAs); glGetIntegerv(GL_SAMPLE_BUFFERS, &glmaxSamplesbuf); debug(LOG_3D, " * (current) Max Sample buffer is %d.", (int) glmaxSamplesbuf); glGetIntegerv(GL_SAMPLES, &glmaxSamples); debug(LOG_3D, " * (current) Max Sample level is %d.", (int) glmaxSamples); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); pie_Skybox_Init(); // Generate backdrop render backdropGfx = new GFX(GFX_TEXTURE, GL_TRIANGLE_STRIP, 2); if (GLEW_ARB_timer_query) { glGenQueries(PERF_COUNT, perfpos); } if (khr_debug) { glDebugMessageCallback((GLDEBUGPROC)khr_callback, NULL); glEnable(GL_DEBUG_OUTPUT); // Do not want to output notifications. Some drivers spam them too much. glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE); debug(LOG_3D, "Enabling KHR_debug message callback"); } glErrors(); return true; }
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure) // If text or lines are blurry when integrating ImGui in your engine: // - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f) void ImGui_ImplSdlGL3_RenderDrawLists(ImDrawData* draw_data) { // Backup GL state GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program); GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer); GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer); GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array); GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src); GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst); GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb); GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha); GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport); GLboolean last_enable_blend = glIsEnabled(GL_BLEND); GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE); GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST); GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST); // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glEnable(GL_SCISSOR_TEST); glActiveTexture(GL_TEXTURE0); // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays) ImGuiIO& io = ImGui::GetIO(); int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x); int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y); draw_data->ScaleClipRects(io.DisplayFramebufferScale); // Setup orthographic projection matrix glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height); const float ortho_projection[4][4] = { { 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f }, { 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f }, { 0.0f, 0.0f, -1.0f, 0.0f }, {-1.0f, 1.0f, 0.0f, 1.0f }, }; glUseProgram(g_ShaderHandle); glUniform1i(g_AttribLocationTex, 0); glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]); glBindVertexArray(g_VaoHandle); for (int n = 0; n < draw_data->CmdListsCount; n++) { const ImDrawList* cmd_list = draw_data->CmdLists[n]; const ImDrawIdx* idx_buffer_offset = 0; glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle); glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle); glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW); for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++) { if (pcmd->UserCallback) { pcmd->UserCallback(cmd_list, pcmd); } else { glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId); glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y)); glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset); } idx_buffer_offset += pcmd->ElemCount; } } // Restore modified GL state glUseProgram(last_program); glBindTexture(GL_TEXTURE_2D, last_texture); glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer); glBindVertexArray(last_vertex_array); glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha); glBlendFunc(last_blend_src, last_blend_dst); if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND); if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST); if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST); glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]); }
bool FBODefinition::Create() { #if MYFW_WINDOWS if( glGenFramebuffers == 0 ) { return false; } #endif #if MYFW_IOS || MYFW_ANDROID //return false; #endif #if !USE_D3D GLint maxsize; glGetIntegerv( GL_MAX_RENDERBUFFER_SIZE, &maxsize ); LOGInfo( LOGTag, "CreateFBO - maxsize: %d\n", maxsize ); #if MYFW_ANDROID int range[2], precision; glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, range, &precision ); LOGInfo( LOGTag, "CreateFBO - High float precision: %d\n", precision ); LOGInfo( LOGTag, "CreateFBO - High float range min: %d\n", range[0] ); LOGInfo( LOGTag, "CreateFBO - High float range max: %d\n", range[1] ); glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT, range, &precision ); LOGInfo( LOGTag, "CreateFBO - Medium float precision: %d\n", precision ); LOGInfo( LOGTag, "CreateFBO - Medium float range min: %d\n", range[0] ); LOGInfo( LOGTag, "CreateFBO - Medium float range max: %d\n", range[1] ); glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_LOW_FLOAT, range, &precision ); LOGInfo( LOGTag, "CreateFBO - Low float precision: %d\n", precision ); LOGInfo( LOGTag, "CreateFBO - Low float range min: %d\n", range[0] ); LOGInfo( LOGTag, "CreateFBO - Low float range max: %d\n", range[1] ); #endif if( m_TextureWidth > (unsigned int)maxsize || m_TextureHeight > (unsigned int)maxsize ) { // requested size is too big. return false; } MyAssert( m_FrameBufferID == 0 ); // get a framebuffer, render buffer and a texture from opengl. glGenFramebuffers( 1, &m_FrameBufferID ); checkGlError( "glGenFramebuffers" ); if( m_NeedColorTexture ) { m_pColorTexture = MyNew TextureDefinition(); glGenTextures( 1, &m_pColorTexture->m_TextureID ); m_pColorTexture->m_MinFilter = m_MinFilter; m_pColorTexture->m_MagFilter = m_MagFilter; m_pColorTexture->m_WrapS = GL_CLAMP_TO_EDGE; m_pColorTexture->m_WrapT = GL_CLAMP_TO_EDGE; m_pColorTexture->m_Width = m_Width; m_pColorTexture->m_Height = m_Height; } checkGlError( "glGenTextures" ); if( m_DepthBits != 0 ) { m_pDepthTexture = MyNew TextureDefinition(); MyAssert( m_DepthBits == 16 || m_DepthBits == 24 || m_DepthBits == 32 ); if( m_DepthIsTexture ) { glGenTextures( 1, &m_pDepthTexture->m_TextureID ); checkGlError( "glGenTextures" ); } else { glGenRenderbuffers( 1, &m_pDepthTexture->m_TextureID ); checkGlError( "glGenRenderbuffers" ); } m_pDepthTexture->m_Width = m_Width; m_pDepthTexture->m_Height = m_Height; } // create the texture if( m_pColorTexture && m_pColorTexture->m_TextureID != 0 ) { glBindTexture( GL_TEXTURE_2D, m_pColorTexture->m_TextureID ); //glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_TextureWidth, m_TextureHeight, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_TextureWidth, m_TextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_MinFilter ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_MagFilter ); glBindTexture( GL_TEXTURE_2D, 0 ); checkGlError( "glBindTexture" ); } // create a depth renderbuffer. if( m_pDepthTexture && m_pDepthTexture->m_TextureID != 0 ) { #if !MYFW_OPENGLES2 GLint depthformat = GL_DEPTH_COMPONENT32; if( m_DepthBits == 24 ) depthformat = GL_DEPTH_COMPONENT24; else if( m_DepthBits == 16 ) depthformat = GL_DEPTH_COMPONENT16; #else GLint depthformat = GL_DEPTH_COMPONENT16; #endif if( m_DepthIsTexture ) { glBindTexture( GL_TEXTURE_2D, m_pDepthTexture->m_TextureID ); checkGlError( "glBindTexture" ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); checkGlError( "glTexParameteri" ); glTexImage2D( GL_TEXTURE_2D, 0, depthformat, m_TextureWidth, m_TextureHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0 ); //GL_DEPTH_COMPONENT, GL_FLOAT, 0 ); checkGlError( "glTexImage2D" ); glBindTexture( GL_TEXTURE_2D, 0 ); checkGlError( "glBindTexture" ); } else { glBindRenderbuffer( GL_RENDERBUFFER, m_pDepthTexture->m_TextureID ); glRenderbufferStorage( GL_RENDERBUFFER, depthformat, m_TextureWidth, m_TextureHeight ); checkGlError( "glRenderbufferStorageEXT" ); } } // attach everything to the FBO { MyBindFramebuffer( GL_FRAMEBUFFER, m_FrameBufferID, 0, 0 ); // attach color texture if( m_pColorTexture && m_pColorTexture->m_TextureID != 0 ) glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_pColorTexture->m_TextureID, 0 ); // attach depth renderbuffer if( m_pDepthTexture && m_pDepthTexture->m_TextureID != 0 ) { if( m_DepthIsTexture ) { glFramebufferTexture2D( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_pDepthTexture->m_TextureID, 0 ); } else { glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_pDepthTexture->m_TextureID ); } } MyBindFramebuffer( GL_FRAMEBUFFER, 0, 0, 0 ); checkGlError( "glBindFramebufferEXT" ); } // any problems? GLint status = glCheckFramebufferStatus( GL_FRAMEBUFFER ); checkGlError( "glCheckFramebufferStatus" ); if( status != GL_FRAMEBUFFER_COMPLETE ) { LOGInfo( LOGTag, "CreateFBO - error\n" ); //MyAssert( false ); Invalidate( true ); return false; } LOGInfo( LOGTag, "CreateFBO - complete (%d, %d)\n", m_TextureWidth, m_TextureHeight ); #else return false; #endif return true; }
void Shader::load(const char *name) { Parser *parser = new Parser(name); // matrixes num_matrixes = 0; for(int i = 0; i < NUM_MATRIXES; i++) { char buf[1024]; sprintf(buf,"matrix%d",i); if(parser->get(buf)) { matrixes[num_matrixes].num = i; getMatrix(parser->get(buf),&matrixes[num_matrixes]); num_matrixes++; } } // vertex program local parameters num_vertex_parameters = 0; for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) { char buf[1024]; sprintf(buf,"vertex_local%d",i); if(parser->get(buf)) { vertex_parameters[num_vertex_parameters].num = i; getLocalParameter(parser->get(buf),&vertex_parameters[num_vertex_parameters]); num_vertex_parameters++; } } // fragement program local parameters num_fragment_parameters = 0; for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) { char buf[1024]; sprintf(buf,"fragment_local%d",i); if(parser->get(buf)) { fragment_parameters[num_fragment_parameters].num = i; getLocalParameter(parser->get(buf),&fragment_parameters[num_fragment_parameters]); num_fragment_parameters++; } } char *data; // vertex program vertex_target = 0; vertex_id = 0; if((data = parser->get("vertex"))) { int error = -1; if(!strncmp(data,"!!ARBvp1.0",10)) { vertex_target = GL_VERTEX_PROGRAM_ARB; glGenProgramsARB(1,&vertex_id); glBindProgramARB(vertex_target,vertex_id); glProgramStringARB(vertex_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data); glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error); } else { char *s = data; while(*s != '\0' && *s != '\n') s++; *s = '\0'; fprintf(stderr,"Shader::Shader(): unknown vertex program header \"%s\" in \"%s\" file\n",data,name); } if(error != -1) { int line = 0; char *s = data; while(error-- && *s) if(*s++ == '\n') line++; while(s >= data && *s != '\n') s--; char *e = ++s; while(*e != '\0' && *e != '\n') e++; *e = '\0'; fprintf(stderr,"Shader::Shader(): vertex program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s); } } // fragment program fragment_target = 0; fragment_id = 0; if((data = parser->get("fragment"))) { int error = -1; if(!strncmp(data,"!!ARBfp1.0",10)) { fragment_target = GL_FRAGMENT_PROGRAM_ARB; glGenProgramsARB(1,&fragment_id); glBindProgramARB(fragment_target,fragment_id); glProgramStringARB(fragment_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data); glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error); } else if(!strncmp(data,"!!FP1.0",7)) { fragment_target = GL_FRAGMENT_PROGRAM_NV; glGenProgramsNV(1,&fragment_id); glBindProgramNV(fragment_target,fragment_id); glLoadProgramNV(fragment_target,fragment_id,strlen(data),(GLubyte*)data); glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV,&error); } else if(!strncmp(data,"!!ARBtec1.0",11)) { // arb texture env combine fragment_target = GL_COMBINE; fragment_id = compileARBtec(data); } else { char *s = data; while(*s != '\0' && *s != '\n') s++; *s = '\0'; fprintf(stderr,"Shader::Shader(): unknown fragment program header \"%s\" in \"%s\" file\n",data,name); } if(error != -1) { int line = 0; char *s = data; while(error-- && *s) if(*s++ == '\n') line++; while(s >= data && *s != '\n') s--; char *e = ++s; while(*e != '\0' && *e != '\n') e++; *e = '\0'; fprintf(stderr,"Shader::Shader(): fragment program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s); } } delete parser; }
//============================================================ // <T>根据代码获得设置内容。</T> // // @param 代码 // @return 内容 //============================================================ TInt GlRenderGetInteger(TInt code){ GLint value = 0; glGetIntegerv(code, &value); return value; }
void opengl_extensions_init() { opengl_get_extensions(); // if S3TC compression is found, then "GL_ARB_texture_compression" must be an extension Use_compressed_textures = Is_Extension_Enabled(OGL_EXT_TEXTURE_COMPRESSION_S3TC); Texture_compression_available = Is_Extension_Enabled(OGL_ARB_TEXTURE_COMPRESSION); // Swifty put this in, but it's not doing anything. Once he uses it, he can uncomment it. //int use_base_vertex = Is_Extension_Enabled(OGL_ARB_DRAW_ELEMENTS_BASE_VERTEX); //allow VBOs to be used if ( !Cmdline_nohtl && !Cmdline_novbo && Is_Extension_Enabled(OGL_ARB_VERTEX_BUFFER_OBJECT) ) { Use_VBOs = 1; } if ( !Cmdline_no_pbo && Is_Extension_Enabled(OGL_ARB_PIXEL_BUFFER_OBJECT) ) { Use_PBOs = 1; } // setup the best fog function found if ( !Fred_running ) { if ( Is_Extension_Enabled(OGL_EXT_FOG_COORD) ) { OGL_fogmode = 2; } else { OGL_fogmode = 1; } } // if we can't do cubemaps then turn off Cmdline_env if ( !(Is_Extension_Enabled(OGL_ARB_TEXTURE_CUBE_MAP) && Is_Extension_Enabled(OGL_ARB_TEXTURE_ENV_COMBINE)) ) { Cmdline_env = 0; } if ( !(Is_Extension_Enabled(OGL_EXT_GEOMETRY_SHADER4) && Is_Extension_Enabled(OGL_EXT_TEXTURE_ARRAY) && Is_Extension_Enabled(OGL_ARB_DRAW_ELEMENTS_BASE_VERTEX)) ) { Cmdline_shadow_quality = 0; mprintf((" No hardware support for shadow mapping. Shadows will be disabled. \n")); } if ( !Cmdline_noglsl && Is_Extension_Enabled(OGL_ARB_SHADER_OBJECTS) && Is_Extension_Enabled(OGL_ARB_FRAGMENT_SHADER) && Is_Extension_Enabled(OGL_ARB_VERTEX_SHADER) ) { int ver = 0, major = 0, minor = 0; const char *glsl_ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION); sscanf(glsl_ver, "%d.%d", &major, &minor); ver = (major * 100) + minor; GLSL_version = ver; // we require a minimum GLSL version if (!is_minimum_GLSL_version()) { mprintf((" OpenGL Shading Language version %s is not sufficient to use GLSL mode in FSO. Defaulting to fixed-function renderer.\n", glGetString(GL_SHADING_LANGUAGE_VERSION) )); } } // can't have this stuff without GLSL support if ( !is_minimum_GLSL_version() ) { Cmdline_normal = 0; Cmdline_height = 0; Cmdline_postprocess = 0; Cmdline_shadow_quality = 0; Cmdline_no_deferred_lighting = 1; } if ( GLSL_version < 120 || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) || !Is_Extension_Enabled(OGL_ARB_FLOATING_POINT_TEXTURES) ) { mprintf((" No hardware support for deferred lighting. Deferred lighting will be disabled. \n")); Cmdline_no_deferred_lighting = 1; Cmdline_no_batching = true; } if (is_minimum_GLSL_version()) { GLint max_texture_units; glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &max_texture_units); // we need enough texture slots for this stuff to work if (max_texture_units < 6) { mprintf(( "Not enough texture units for height map support. We need at least 6, we found %d.\n", max_texture_units )); Cmdline_height = 0; } else if (max_texture_units < 5) { mprintf(( "Not enough texture units for height and normal map support. We need at least 5, we found %d.\n", max_texture_units )); Cmdline_normal = 0; Cmdline_height = 0; } else if (max_texture_units < 4) { mprintf(( "Not enough texture units found for GLSL support. We need at least 4, we found %d.\n", max_texture_units )); GLSL_version = 0; } } }
void gl_renderer::init() { const SDL_VideoInfo* info = NULL; bpp = 0; flags = SDL_OPENGL | SDL_RESIZABLE; //width = 640; //height = 480; width = 1024; height = 786; angle = 0; GLint stencil = 0; current_camera = game_camera[0] = new desktop_camera(); /* ----- SDL init --------------- */ if(SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Video initialization failed: %s\n", SDL_GetError()); exit(-1); } atexit(SDL_Quit); info = SDL_GetVideoInfo(); bpp = info->vfmt->BitsPerPixel; /* ----- OpenGL attribute setting via SDL --------------- */ 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_STENCIL_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); /* ----- Setting up the screen surface --------------- */ screen = SDL_SetVideoMode(width, height, bpp, flags); if (screen == 0) { fprintf(stderr, "Video mode set failed: %s\n", SDL_GetError()); exit(-1); } glGetIntegerv(GL_STENCIL_BITS, &stencil); if(stencil == 0){ printf("Stencil buffer not available!\n"); exit(-1); } SDL_WM_SetCaption("Norbit fridge in space simulator", NULL); light1 = (Light){{ 0.0f, 1.5f,-1.5f, 1.0f}, { 0.7f, 0.7f, 0.7f, 1.0f}, { 0.7f, 0.7f, 0.7f, 1.0f}, { 1.0f, 1.0f, 1.0f, 1.0f}}; light2 = (Light){{-1.5f,-1.8f, 0.0f, 1.0f}, { 0.4f, 0.4f, 0.4f, 1.0f}, { 0.4f, 0.4f, 0.4f, 1.0f}, { 1.0f, 1.0f, 1.0f, 1.0f}}; /* ----- OpenGL init --------------- */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); /* The following function replaces gluPerspective */ gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.001f, 100000.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_TEXTURE_2D); glEnable(GL_COLOR_MATERIAL); glShadeModel(GL_SMOOTH); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glDepthFunc(GL_LEQUAL); glEnable(GL_DEPTH_TEST); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT1); glEnable(GL_LIGHT2); ship_shape = new obj_shape(new string("ptr_mk1.obj")); star_shape = new sphere_shape(5.0f); background_stars = new skybox(); background_stars->init(200.0f); }
static void Init( int argc, char *argv[] ) { GLuint texObj[2]; GLint units; if (!glutExtensionSupported("GL_ARB_multitexture")) { printf("Sorry, GL_ARB_multitexture not supported by this renderer.\n"); exit(1); } if (!glutExtensionSupported("GL_EXT_paletted_texture")) { printf("Sorry, GL_EXT_paletted_texture not supported by this renderer.\n"); exit(1); } glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &units); printf("%d texture units supported\n", units); /* allocate two texture objects */ glGenTextures(2, texObj); /* setup texture obj 0 */ glBindTexture(GL_TEXTURE_2D, texObj[0]); #ifdef LINEAR_FILTER /* linear filtering looks much nicer but is much slower for Mesa */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); foo #else glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); #endif glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); load_tex(TEXTURE_1_FILE, 0); #if 0 if (!LoadRGBMipmaps(TEXTURE_1_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } #endif /* setup texture obj 1 */ glBindTexture(GL_TEXTURE_2D, texObj[1]); #ifdef LINEAR_FILTER /* linear filtering looks much nicer but is much slower for Mesa */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); foo #else glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); #endif glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); load_tex(TEXTURE_2_FILE, 1); #if 0 if (!LoadRGBMipmaps(TEXTURE_2_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } #endif /* now bind the texture objects to the respective texture units */ #ifdef GL_ARB_multitexture glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, texObj[0]); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, texObj[1]); #endif glShadeModel(GL_FLAT); glClearColor(0.3, 0.3, 0.4, 1.0); ModeMenu(TEXBOTH); if (argc > 1 && strcmp(argv[1], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } }
bool CRenderSystemGLES::InitRenderSystem() { GLint maxTextureSize; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); m_maxTextureSize = maxTextureSize; m_bVSync = false; m_iVSyncMode = 0; m_iSwapStamp = 0; m_iSwapTime = 0; m_iSwapRate = 0; m_bVsyncInit = false; m_renderCaps = 0; // Get the GLES version number m_RenderVersionMajor = 0; m_RenderVersionMinor = 0; const char* ver = (const char*)glGetString(GL_VERSION); if (ver != 0) { sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor); if (!m_RenderVersionMajor) sscanf(ver, "%*s %*s %d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor); m_RenderVersion = ver; } // Get our driver vendor and renderer m_RenderVendor = (const char*) glGetString(GL_VENDOR); m_RenderRenderer = (const char*) glGetString(GL_RENDERER); m_RenderExtensions = " "; m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS); m_RenderExtensions += " "; LogGraphicsInfo(); if (IsExtSupported("GL_TEXTURE_NPOT")) { m_renderCaps |= RENDER_CAPS_NPOT; } if (IsExtSupported("GL_EXT_texture_format_BGRA8888")) { m_renderCaps |= RENDER_CAPS_BGRA; } if (IsExtSupported("GL_IMG_texture_format_BGRA8888")) { m_renderCaps |= RENDER_CAPS_BGRA; } if (IsExtSupported("GL_APPLE_texture_format_BGRA8888")) { m_renderCaps |= RENDER_CAPS_BGRA_APPLE; } m_bRenderCreated = true; InitialiseGUIShader(); return true; }
static CoglBool _cogl_driver_update_features (CoglContext *context, CoglError **error) { CoglPrivateFeatureFlags private_flags = 0; char **gl_extensions; /* We have to special case getting the pointer to the glGetString function because we need to use it to determine what functions we can expect */ context->glGetString = (void *) _cogl_renderer_get_proc_address (context->display->renderer, "glGetString", TRUE); gl_extensions = _cogl_context_get_gl_extensions (context); if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_WINSYS))) { char *all_extensions = g_strjoinv (" ", gl_extensions); COGL_NOTE (WINSYS, "Checking features\n" " GL_VENDOR: %s\n" " GL_RENDERER: %s\n" " GL_VERSION: %s\n" " GL_EXTENSIONS: %s", context->glGetString (GL_VENDOR), context->glGetString (GL_RENDERER), _cogl_context_get_gl_version (context), all_extensions); g_free (all_extensions); } context->glsl_major = 1; context->glsl_minor = 0; _cogl_gpu_info_init (context, &context->gpu); _cogl_feature_check_ext_functions (context, -1 /* GL major version */, -1 /* GL minor version */, gl_extensions); #ifdef HAVE_COGL_GLES if (context->driver == COGL_DRIVER_GLES1) { int max_clip_planes; GE( context, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) ); if (max_clip_planes >= 4) private_flags |= COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES; } #endif if (context->driver == COGL_DRIVER_GLES2) { /* Note GLES 2 core doesn't support mipmaps for npot textures or * repeat modes other than CLAMP_TO_EDGE. */ COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_GLSL, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_RANGE, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE, TRUE); private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT; } else if (context->driver == COGL_DRIVER_GLES1) private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED | COGL_PRIVATE_FEATURE_ALPHA_TEST | COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM); private_flags |= (COGL_PRIVATE_FEATURE_VBOS | COGL_PRIVATE_FEATURE_ANY_GL | COGL_PRIVATE_FEATURE_ALPHA_TEXTURES); /* Both GLES 1.1 and GLES 2.0 support point sprites in core */ COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE); if (context->glGenRenderbuffers) COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE); if (context->glBlitFramebuffer) private_flags |= COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT; if (_cogl_check_extension ("GL_OES_element_index_uint", gl_extensions)) COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_UNSIGNED_INT_INDICES, TRUE); if (_cogl_check_extension ("GL_OES_depth_texture", gl_extensions)) COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_TEXTURE, TRUE); if (_cogl_check_extension ("GL_OES_texture_npot", gl_extensions)) { COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, TRUE); } else if (_cogl_check_extension ("GL_IMG_texture_npot", gl_extensions)) { COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE); COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE); } if (context->glTexImage3D) COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_3D, TRUE); if (context->glMapBuffer) /* The GL_OES_mapbuffer extension doesn't support mapping for read */ COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE, TRUE); if (context->glEGLImageTargetTexture2D) private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE; if (_cogl_check_extension ("GL_OES_packed_depth_stencil", gl_extensions)) private_flags |= COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL; if (_cogl_check_extension ("GL_EXT_texture_format_BGRA8888", gl_extensions)) private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888; if (_cogl_check_extension ("GL_EXT_unpack_subimage", gl_extensions)) private_flags |= COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE; /* A nameless vendor implemented the extension, but got the case wrong * per the spec. */ if (_cogl_check_extension ("GL_OES_EGL_sync", gl_extensions) || _cogl_check_extension ("GL_OES_egl_sync", gl_extensions)) private_flags |= COGL_PRIVATE_FEATURE_OES_EGL_SYNC; /* Cache features */ context->private_feature_flags |= private_flags; g_strfreev (gl_extensions); return TRUE; }