/* ** This is a screwball function. What it does is the following: ** Given screen x and y coordinates, compute the corresponding object space ** x and y coordinates given that the object space z is 0.9 + OFFSETZ. ** Since the tops of (most) pieces are at z = 0.9 + OFFSETZ, we use that ** number. */ int computeCoords(int piece, int mousex, int mousey, GLfloat * selx, GLfloat * sely) { GLfloat modelMatrix[16]; GLfloat projMatrix[16]; GLfloat finalMatrix[16]; GLfloat in[4]; GLfloat a, b, c, d; GLfloat top, bot; GLfloat z; GLfloat w; GLfloat height; if (piece == 0) return 0; height = zsize[piece] - 0.1 + OFFSETZ; glGetFloatv(GL_PROJECTION_MATRIX, projMatrix); glGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix); multMatrices(modelMatrix, projMatrix, finalMatrix); if (!invertMatrix(finalMatrix, finalMatrix)) return 0; in[0] = (2.0 * (mousex - viewport[0]) / viewport[2]) - 1; in[1] = (2.0 * ((H - mousey) - viewport[1]) / viewport[3]) - 1; a = in[0] * finalMatrix[0 * 4 + 2] + in[1] * finalMatrix[1 * 4 + 2] + finalMatrix[3 * 4 + 2]; b = finalMatrix[2 * 4 + 2]; c = in[0] * finalMatrix[0 * 4 + 3] + in[1] * finalMatrix[1 * 4 + 3] + finalMatrix[3 * 4 + 3]; d = finalMatrix[2 * 4 + 3]; /* ** Ok, now we need to solve for z: ** (a + b z) / (c + d z) = height. ** ("height" is the height in object space we want to solve z for) ** ** ==> a + b z = height c + height d z ** bz - height d z = height c - a ** z = (height c - a) / (b - height d) */ top = height * c - a; bot = b - height * d; if (bot == 0.0) return 0; z = top / bot; /* ** Ok, no problem. ** Now we solve for x and y. We know that w = c + d z, so we compute it. */ w = c + d * z; /* ** Now for x and y: */ *selx = (in[0] * finalMatrix[0 * 4 + 0] + in[1] * finalMatrix[1 * 4 + 0] + z * finalMatrix[2 * 4 + 0] + finalMatrix[3 * 4 + 0]) / w - OFFSETX; *sely = (in[0] * finalMatrix[0 * 4 + 1] + in[1] * finalMatrix[1 * 4 + 1] + z * finalMatrix[2 * 4 + 1] + finalMatrix[3 * 4 + 1]) / w - OFFSETY; return 1; }
void transformVecByModelView(float outVec[4], float inVec[4]){ float modelview[16]; glGetFloatv( GL_MODELVIEW_MATRIX, modelview ); matMultVec4f( outVec, inVec, modelview ); }
/* ============= R_SetupGL ============= */ void R_SetupGL (void) { float screenaspect; float yfov; int i; extern int glwidth, glheight; int x, x2, y2, y, w, h; // // set up viewpoint // glMatrixMode(GL_PROJECTION); glLoadIdentity (); x = r_refdef.vrect.x * glwidth/vid.width; x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth/vid.width; y = (vid.height-r_refdef.vrect.y) * glheight/vid.height; y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight/vid.height; // fudge around because of frac screen scale if (x > 0) x--; if (x2 < glwidth) x2++; if (y2 < 0) y2--; if (y < glheight) y++; w = x2 - x; h = y - y2; if (envmap) { x = y2 = 0; w = h = 256; } glViewport (glx + x, gly + y2, w, h); screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height; // yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI; MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096); if (mirror) { if (mirror_plane->normal[2]) glScalef (1, -1, 1); else glScalef (-1, 1, 1); glCullFace(GL_BACK); } else glCullFace(GL_FRONT); glMatrixMode(GL_MODELVIEW); #ifdef DO_OWN_MATRIX_MATH float mv[16]; setIdentityM(mv, 0); rotateM(mv, -90, 1, 0, 0); // put Z going up rotateM(mv, 90, 0, 0, 1); // put Z going up rotateM(mv, -r_refdef.viewangles[2], 1, 0, 0); rotateM(mv, -r_refdef.viewangles[0], 0, 1, 0); rotateM(mv, -r_refdef.viewangles[1], 0, 0, 1); translateM(mv, 0, -r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]); glLoadMatrixf(mv); memcpy(r_world_matrix, mv, sizeof(r_world_matrix)); #else glLoadIdentity (); glRotatef (-90, 1, 0, 0); // put Z going up glRotatef (90, 0, 0, 1); // put Z going up glRotatef (-r_refdef.viewangles[2], 1, 0, 0); glRotatef (-r_refdef.viewangles[0], 0, 1, 0); glRotatef (-r_refdef.viewangles[1], 0, 0, 1); glTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]); #ifdef USE_OPENGLES static qboolean initialized; static qboolean haveGL_OES_matrix_get; static qboolean haveGL_OES_query_matrix; #if 0 if (! initialized) { const char* extensions = (const char*) glGetString(GL_EXTENSIONS); haveGL_OES_matrix_get = strstr(extensions, "GL_OES_matrix_get") != NULL; haveGL_OES_query_matrix = strstr(extensions, "GL_OES_query_matrix") != NULL; initialized = true; } if (haveGL_OES_query_matrix) { GLfixed mantissa[16]; GLint exponent[16]; glQueryMatrixxOES( mantissa, exponent ); for(int i = 0; i < 16; i++) { r_world_matrix[i] = scalbnf(mantissa[i], exponent[i]-16); } } else if (haveGL_OES_matrix_get) { glGetIntegerv (MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES, (GLint*) r_world_matrix); } else #endif { // No way to get the world matix, set to identity memset(r_world_matrix, 0, sizeof(r_world_matrix)); for(i = 0; i < 16; i += 5) { r_world_matrix[i] = 1.0f; } } #else glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix); #endif #endif // DO_OWN_MATRIX_MATH // // set drawing parms // if (gl_cull.value) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); glEnable(GL_DEPTH_TEST); }
float glaGetOneFloat(int param) { GLfloat v; glGetFloatv(param, &v); return v; }
void C_Frustum::calculateFrustum(void) { float proj[16]; // This will hold our projection matrix float modl[16]; // This will hold our modelview matrix float clip[16]; // This will hold the clipping planes glGetFloatv(GL_PROJECTION_MATRIX, proj); glGetFloatv(GL_MODELVIEW_MATRIX, modl); clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12]; clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13]; clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14]; clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15]; clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12]; clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13]; clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14]; clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15]; clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12]; clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13]; clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14]; clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15]; clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12]; clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13]; clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14]; clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15]; right->setPlane ( clip[ 3] - clip[ 0] , clip[ 7] - clip[ 4] , clip[11] - clip[ 8] , clip[15] - clip[12] ); left->setPlane ( clip[ 3] + clip[ 0] , clip[ 7] + clip[ 4] , clip[11] + clip[ 8] , clip[15] + clip[12] ); bottom->setPlane ( clip[ 3] + clip[ 1] , clip[ 7] + clip[ 5] , clip[11] + clip[ 9] , clip[15] + clip[13] ); top->setPlane ( clip[ 3] - clip[ 1] , clip[ 7] - clip[ 5] , clip[11] - clip[ 9] , clip[15] - clip[13] ); back->setPlane ( clip[ 3] - clip[ 2] , clip[ 7] - clip[ 6] , clip[11] - clip[10] , clip[15] - clip[14] ); front->setPlane ( clip[ 3] + clip[ 2] , clip[ 7] + clip[ 6] , clip[11] + clip[10] , clip[15] + clip[14] ); right->normalizePlane(); left->normalizePlane(); bottom->normalizePlane(); top->normalizePlane(); back->normalizePlane(); front->normalizePlane(); }
bool checkGLState(GLenum pname, const glm::vec4 value) { glm::vec4 v; glGetFloatv(pname, reinterpret_cast<float*>(&v[0])); return (v == value); }
//------------------------------------------------------------------------------ // drawFunc() - draw our objects //------------------------------------------------------------------------------ void CrsPntr::drawFunc() { GLfloat ocolor[4]; GLfloat lw; glGetFloatv(GL_CURRENT_COLOR, ocolor); glGetFloatv(GL_LINE_WIDTH, &lw); glColor3f(1, 1, 1); glLineWidth(2); if (showCrsPtr) { // this is the course pointer glPushMatrix(); glBegin(GL_LINE_STRIP); glVertex2f(0.044f, 0.49f); glVertex2f(0.044f, 0.865f); glVertex2f(0, 1.065f); glVertex2f(-0.044f, 0.865f); glVertex2f(-0.044f, 0.49f); glVertex2f(0.044f, 0.49f); glEnd(); glBegin(GL_LINE_STRIP); glVertex2f(0, -0.6f); glVertex2f(-0.044f, -0.676f); glVertex2f(-0.044f, -1.1f); glVertex2f( 0.044f, -1.1f); glVertex2f( 0.044f, -0.676f); glVertex2f(0, -0.6f); glEnd(); glPopMatrix(); } if (showCdi) { // figure how far to translate LCreal scale = inchesPerDot * cdiDots; // limit ourself to the size of the scale if (scale > 0.88) scale = 0.88f; if (scale < -0.88) scale = -0.88f; // cdi glPushMatrix(); glTranslatef(static_cast<GLfloat>(scale), 0, 0); glBegin(GL_LINE_STRIP); glVertex2f(-0.044f, -0.45f); glVertex2f(0.044f, -0.45f); glVertex2f(0.044f, 0.35f); glVertex2f(-0.044f, 0.35f); glVertex2f(-0.044f, -0.45f); glEnd(); glPopMatrix(); } // our to from arrow will not be display unless we get a 1 (to) or a 0 (from) if (showToFrom) { if (toFrom == 1) { glPushMatrix(); glBegin(GL_POLYGON); glVertex2f(0, -0.6f); glVertex2f(-0.044f, -0.475f); glVertex2f(0.044f, -0.475f); glEnd(); glPopMatrix(); } if (toFrom == 0) { glPushMatrix(); glBegin(GL_POLYGON); glVertex2f(0, 0.475f); glVertex2f(-0.044f, 0.37f); glVertex2f(0.044f, 0.37f); glEnd(); glPopMatrix(); } } glColor4fv(ocolor); glLineWidth(lw); }
// The face knows where it needs to rotate to. // Pass the current perspective to the face and load the returned perspective rotation. void rotateToFace(int faceNum) { GLfloat matrix[16]; glGetFloatv(GL_MODELVIEW_MATRIX, matrix); face[faceNum]->rotateToSelf(matrix); glLoadMatrixf(matrix); }
void CGlobalRendering::PostInit() { supportNPOTs = GLEW_ARB_texture_non_power_of_two; haveARB = GLEW_ARB_vertex_program && GLEW_ARB_fragment_program; haveGLSL = (glGetString(GL_SHADING_LANGUAGE_VERSION) != NULL); haveGLSL &= GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader; haveGLSL &= !!GLEW_VERSION_2_0; // we want OpenGL 2.0 core functions { const char* glVendor = (const char*) glGetString(GL_VENDOR); const char* glRenderer = (const char*) glGetString(GL_RENDERER); const std::string vendor = (glVendor != NULL)? StringToLower(std::string(glVendor)): ""; const std::string renderer = (glRenderer != NULL)? StringToLower(std::string(glRenderer)): ""; haveATI = (vendor.find("ati ") != std::string::npos) || (vendor.find("amd ") != std::string::npos); haveMesa = (renderer.find("mesa ") != std::string::npos) || (renderer.find("gallium ") != std::string::npos); haveIntel = (vendor.find("intel") != std::string::npos); haveNvidia = (vendor.find("nvidia ") != std::string::npos); //FIXME Neither Intel's nor Mesa's GLSL implementation seem to be in a workable state atm (date: Nov. 2011) haveGLSL &= !haveIntel; haveGLSL &= !haveMesa; //FIXME add an user config to force enable it! if (haveATI) { // x-series doesn't support NPOTs (but hd-series does) supportNPOTs = (renderer.find(" x") == std::string::npos && renderer.find(" 9") == std::string::npos); } } // use some ATI bugfixes? const int atiHacksCfg = configHandler->GetInt("AtiHacks"); atiHacks = haveATI && (atiHacksCfg < 0); // runtime detect atiHacks |= (atiHacksCfg > 0); // user override // Runtime compress textures? if (GLEW_ARB_texture_compression) { // we don't even need to check it, 'cos groundtextures must have that extension // default to off because it reduces quality (smallest mipmap level is bigger) compressTextures = configHandler->GetBool("CompressTextures"); } #ifdef GLEW_NV_primitive_restart supportRestartPrimitive = !!(GLEW_NV_primitive_restart); #endif // maximum 2D texture size { glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); } // retrieve maximu smoothed PointSize float2 aliasedPointSizeRange, smoothPointSizeRange; glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*)&aliasedPointSizeRange); glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, (GLfloat*)&smoothPointSizeRange); maxSmoothPointSize = std::min(aliasedPointSizeRange.y, smoothPointSizeRange.y); // some GLSL relevant information { glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &glslMaxUniformBufferBindings); glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &glslMaxUniformBufferSize); glGetIntegerv(GL_MAX_VARYING_FLOATS, &glslMaxVaryings); glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &glslMaxAttributes); glGetIntegerv(GL_MAX_DRAW_BUFFERS, &glslMaxDrawBuffers); glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &glslMaxRecommendedIndices); glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &glslMaxRecommendedVertices); glslMaxVaryings /= 4; // GL_MAX_VARYING_FLOATS returns max individual floats, we want float4 } // detect if GL_DEPTH_COMPONENT24 is supported (many ATIs don't do so) { // ATI seems to support GL_DEPTH_COMPONENT24 for static textures, but you can't render to them /* GLint state = 0; glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 16, 16, 0, GL_LUMINANCE, GL_FLOAT, NULL); glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &state); support24bitDepthBuffers = (state > 0); */ support24bitDepthBuffers = false; if (FBO::IsSupported() && !atiHacks) { const int fboSizeX = 16, fboSizeY = 16; FBO fbo; fbo.Bind(); fbo.CreateRenderBuffer(GL_COLOR_ATTACHMENT0_EXT, GL_RGBA8, fboSizeX, fboSizeY); fbo.CreateRenderBuffer(GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_COMPONENT24, fboSizeX, fboSizeY); const GLenum status = fbo.GetStatus(); fbo.Unbind(); support24bitDepthBuffers = (status == GL_FRAMEBUFFER_COMPLETE_EXT); } } // print info LOG( "GL info:\n" "\thaveARB: %i, haveGLSL: %i, ATI hacks: %i\n" "\tFBO support: %i, NPOT-texture support: %i, 24bit Z-buffer support: %i\n" "\tmaximum texture size: %i, compress MIP-map textures: %i\n" "\tmaximum SmoothPointSize: %0.0f, maximum vec4 varying/attributes: %i/%i\n" "\tmaximum drawbuffers: %i, maximum recommended indices/vertices: %i/%i\n" "\tnumber of UniformBufferBindings: %i (%ikB)", haveARB, haveGLSL, atiHacks, FBO::IsSupported(), supportNPOTs, support24bitDepthBuffers, maxTextureSize, compressTextures, maxSmoothPointSize, glslMaxVaryings, glslMaxAttributes, glslMaxDrawBuffers, glslMaxRecommendedIndices, glslMaxRecommendedVertices, glslMaxUniformBufferBindings, glslMaxUniformBufferSize / 1024 ); teamNanospray = configHandler->GetBool("TeamNanoSpray"); }
int main(int argc, char *argv[]) { SDL_Surface *screen; if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL ); if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); glGenVertexArrays_ = (PFNGLGENVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glGenVertexArrays"); assert(glGenVertexArrays_); glBindVertexArray_ = (PFNGLBINDVERTEXARRAYPROC) SDL_GL_GetProcAddress("glBindVertexArray"); assert(glBindVertexArray_); glDeleteVertexArrays_ = (PFNGLDELETEVERTEXARRAYSPROC) SDL_GL_GetProcAddress("glDeleteVertexArrays"); assert(glDeleteVertexArrays_); glEnableClientState(GL_TEXTURE_COORD_ARRAY); // enabling it *before* the vao does nothing, the vao should wipe it out! // Generate a VAO GLuint vao; glGenVertexArrays_(1, &vao); glBindVertexArray_(vao); // Create a texture GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte textureData[16*16*4]; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8); } } glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); // Create a second texture GLuint texture2; glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte texture2Data[] = { 0xff, 0, 0, 0xff, 0, 0xff, 0, 0xaa, 0, 0, 0xff, 0x55, 0x80, 0x90, 0x70, 0 }; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2Data ); // BEGIN #if USE_GLEW glewInit(); #endif glMatrixMode(GL_PROJECTION); glLoadIdentity(); // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048); //glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048); GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 }; glLoadMatrixf(pm); glMatrixMode(GL_MODELVIEW); GLfloat matrixData[] = { -1, 0, 0, 0, 0, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 1 }; glLoadMatrixf(matrixData); //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown // glEnable(GL_CULL_FACE); // glEnable(GL_DEPTH_TEST); //glClear(GL_DEPTH_BUFFER_BIT); // glEnableClientState(GL_NORMAL_ARRAY); // glEnableClientState(GL_COLOR_ARRAY); glActiveTexture(GL_TEXTURE0); glEnableClientState(GL_VERTEX_ARRAY); GLuint arrayBuffer, elementBuffer; glGenBuffers(1, &arrayBuffer); glGenBuffers(1, &elementBuffer); GLubyte arrayData[] = { /* [0, 0, 0, 67] ==> 128 float [0, 0, 128, 67] ==> 256 float [0, 0, 0, 68] ==> 512 float [0, 0, 128, 68] ==> 1024 float [vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128 }; assert(sizeof(arrayData) == 1408); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 }; assert(sizeof(elementData) == 48); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound glTexCoordPointer(2, GL_FLOAT, 32, (void*)16); // glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build // glTexCoordPointer(2, GL_SHORT, 32, (void*)24); // glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup // glNormalPointer(GL_BYTE, 32, (void*)12); // glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28); glBindTexture(GL_TEXTURE_2D, texture); // diffuse? glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); // lightmap? glActiveTexture(GL_TEXTURE0); GLint ok; const char *vertexShader = "uniform mat4 u_modelView;\n" "uniform mat4 u_projection;\n" "varying vec4 v_texCoord0;\n" "void main(void)\n" "{\n" // (gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex) // (u_projection * u_modelView * a_position) " gl_Position = (u_projection * u_modelView * gl_Vertex) + vec4(200, 0, 0, 0);\n" " v_texCoord0.xy = gl_MultiTexCoord0.xy/20.0;\n" // added /100 here "}\n"; const char *fragmentShader = "uniform sampler2D diffusemap;\n" "varying vec4 v_texCoord0;\n" "void main(void)\n" "{\n" " vec4 diffuse = texture2D(diffusemap, v_texCoord0.xy);\n" " gl_FragColor = diffuse;\n" "}\n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vertexShader, NULL); glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &ok); if (!ok) { printf("Shader compilation error with vertex\n"); GLint infoLen = 0; glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen > 1) { char* infoLog = (char *)malloc(sizeof(char) * infoLen+1); glGetShaderInfoLog(vs, infoLen, NULL, infoLog); printf("Error compiling shader:\n%s\n", infoLog); } } GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fragmentShader, NULL); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &ok); if (!ok) { printf("Shader compilation error with fragment\n"); GLint infoLen = 0; glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen); if (infoLen > 1) { char* infoLog = (char *)malloc(sizeof(char) * infoLen+1); glGetShaderInfoLog(vs, infoLen, NULL, infoLog); printf("Error compiling shader:\n%s\n", infoLog); } } GLuint program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(program); //GLint lightmapLocation = glGetUniformLocation(program, "lightmap"); //assert(lightmapLocation >= 0); //glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit? GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap"); assert(diffusemapLocation >= 0); glUniform1i(diffusemapLocation, 0); //GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll"); //assert(texgenscrollLocation >= 0); //GLint colorparamsLocation = glGetUniformLocation(program, "colorparams"); //assert(colorparamsLocation >= 0); //GLfloat texgenscrollData[] = { 0, 0, 0, 0 }; //glUniform4fv(texgenscrollLocation, 1, texgenscrollData); //GLfloat colorparamsData[] = { 2, 2, 2, 1 }; //glUniform4fv(colorparamsLocation, 1, colorparamsData); { GLfloat data[16]; glGetFloatv(GL_MODELVIEW_MATRIX, data); printf("Modelview: "); for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]); printf("\n"); //memset(data, 0, 16*4); GLint modelViewLocation = glGetUniformLocation(program, "u_modelView"); assert(modelViewLocation >= 0); glUniformMatrix4fv(modelViewLocation, 1, GL_FALSE, data); } { GLfloat data[16]; glGetFloatv(GL_PROJECTION_MATRIX, data); printf("Projection: "); for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]); printf("\n"); //memset(data, 0, 16*4); GLint projectionLocation = glGetUniformLocation(program, "u_projection"); assert(projectionLocation >= 0); glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, data); } /* glBindAttribLocation(program, 0, "a_position"); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, (void*)0); glEnableVertexAttribArray(0); glBindAttribLocation(program, 1, "v_texCoord0"); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 32, (void*)16); glEnableVertexAttribArray(1); */ // stop recording in the VAO glBindVertexArray_(0); // unbind all the stuff the VAO would save for us, so this is a valid test glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); // draw with VAO glBindVertexArray_(vao); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36); // END SDL_GL_SwapBuffers(); #if !EMSCRIPTEN SDL_Delay(1500); #endif // SDL_Quit(); return 0; }
/** * @brief Loads a surface into an opengl texture. * * @param surface Surface to load into a texture. * @param flags Flags to use. * @param[out] rw Real width of the texture. * @param[out] rh Real height of the texture. * @return The opengl texture id. */ static GLuint gl_loadSurface( SDL_Surface* surface, int *rw, int *rh, unsigned int flags, int freesur ) { GLuint texture; GLfloat param; /* Prepare the surface. */ surface = gl_prepareSurface( surface ); if (rw != NULL) (*rw) = surface->w; if (rh != NULL) (*rh) = surface->h; /* opengl texture binding */ glGenTextures( 1, &texture ); /* Creates the texture */ glBindTexture( GL_TEXTURE_2D, texture ); /* Loads the texture */ /* Filtering, LINEAR is better for scaling, nearest looks nicer, LINEAR * also seems to create a bit of artifacts around the edges */ if ((gl_screen.scale != 1.) || (flags & OPENGL_TEX_MIPMAPS)) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } /* Always wrap just in case. */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); /* now lead the texture data up */ SDL_LockSurface( surface ); if (gl_texHasCompress()) { glTexImage2D( GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, GL_COMPRESSED_RGBA, GL_UNSIGNED_BYTE, surface->pixels ); } else { glTexImage2D( GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels ); } SDL_UnlockSurface( surface ); /* Create mipmaps. */ if ((flags & OPENGL_TEX_MIPMAPS) && gl_texHasMipmaps()) { /* Do fancy stuff. */ if (gl_hasExt("GL_EXT_texture_filter_anisotropic")) { glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, ¶m); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, param); } glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 9); /* Now generate the mipmaps. */ nglGenerateMipmap(GL_TEXTURE_2D); } /* cleanup */ if (freesur) SDL_FreeSurface( surface ); gl_checkErr(); return texture; }
PsychError SCREENDrawDots(void) { PsychWindowRecordType *windowRecord; int whiteValue, m,n,p,mc,nc,pc,idot_type; int i, nrpoints, nrsize; boolean isArgThere, usecolorvector, isdoublecolors, isuint8colors; double *xy, *size, *center, *dot_type, *colors; unsigned char *bytecolors; GLfloat pointsizerange[2]; double convfactor; // All sub functions should have these two lines PsychPushHelp(useString, synopsisString,seeAlsoString); if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}; // Check for superfluous arguments PsychErrorExit(PsychCapNumInputArgs(6)); //The maximum number of inputs PsychErrorExit(PsychCapNumOutputArgs(0)); //The maximum number of outputs // Get the window record from the window record argument and get info from the window record PsychAllocInWindowRecordArg(1, kPsychArgRequired, &windowRecord); // Query, allocate and copy in all vectors... nrpoints = 2; nrsize = 0; colors = NULL; bytecolors = NULL; PsychPrepareRenderBatch(windowRecord, 2, &nrpoints, &xy, 4, &nc, &mc, &colors, &bytecolors, 3, &nrsize, &size); isdoublecolors = (colors) ? TRUE:FALSE; isuint8colors = (bytecolors) ? TRUE:FALSE; usecolorvector = (nc>1) ? TRUE:FALSE; // Get center argument isArgThere = PsychIsArgPresent(PsychArgIn, 5); if(!isArgThere){ center = (double *) PsychMallocTemp(2 * sizeof(double)); center[0] = 0; center[1] = 0; } else { PsychAllocInDoubleMatArg(5, TRUE, &m, &n, &p, ¢er); if(p!=1 || n!=2 || m!=1) PsychErrorExitMsg(PsychError_user, "center must be a 1-by-2 vector"); } // Get dot_type argument isArgThere = PsychIsArgPresent(PsychArgIn, 6); if(!isArgThere){ idot_type = 0; } else { PsychAllocInDoubleMatArg(6, TRUE, &m, &n, &p, &dot_type); if(p!=1 || n!=1 || m!=1 || (dot_type[0]<0 || dot_type[0]>2)) PsychErrorExitMsg(PsychError_user, "dot_type must be 0, 1 or 2"); idot_type = (int) dot_type[0]; } // Child-protection: Alpha blending needs to be enabled for smoothing to work: // Ok, not such a good idea :-( The flag also enables drawing of round dots and // there are applications were we want to set the flag without using alpha blending... // Therefore disabled -> May want to turn this into some kind of warning or hint in the future... if (idot_type>0 && windowRecord->actualEnableBlending!=TRUE) { //PsychErrorExitMsg(PsychError_user, "Point smoothing doesn't work with alpha-blending disabled! See Screen('BlendFunction') on how to enable it."); } // Turn on antialiasing to draw circles if(idot_type) { glEnable(GL_POINT_SMOOTH); glGetFloatv(GL_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange); // A dot type of 2 requests for highest quality point smoothing: glHint(GL_POINT_SMOOTH_HINT, (idot_type>1) ? GL_NICEST : GL_DONT_CARE); } else { #ifndef GL_ALIASED_POINT_SIZE_RANGE #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #endif glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, (GLfloat*) &pointsizerange); } // Set size of a single dot: if (size[0] > pointsizerange[1] || size[0] < pointsizerange[0]) { printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n", size[0], pointsizerange[0], pointsizerange[1]); PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots')."); } // Setup initial common point size for all points: glPointSize(size[0]); // Setup modelview matrix to perform translation by 'center': glMatrixMode(GL_MODELVIEW); // Make a backup copy of the matrix: glPushMatrix(); // Apply a global translation of (center(x,y)) pixels to all following points: glTranslated(center[0], center[1], 0); // Render the array of 2D-Points - Efficient version: // This command sequence allows fast processing of whole arrays // of vertices (or points, in this case). It saves the call overhead // associated with the original implementation below and is potentially // optimized in specific OpenGL implementations. // Pass a pointer to the start of the point-coordinate array: glVertexPointer(2, GL_DOUBLE, 0, &xy[0]); // Enable fast rendering of arrays: glEnableClientState(GL_VERTEX_ARRAY); if (usecolorvector) { PsychSetupVertexColorArrays(windowRecord, TRUE, mc, colors, bytecolors); } // Render all n points, starting at point 0, render them as POINTS: if (nrsize==1) { // One common point size for all dots provided. Good! This is very efficiently // done with one single render-call: glDrawArrays(GL_POINTS, 0, nrpoints); } else { // Different size for each dot provided: We have to do One GL - call per dot. // This is *pretty inefficient* and should be reimplemented in the future via // Point-Sprite extensions, cleverly used display lists or via vertex-shaders... // For now we do it the stupid way: for (i=0; i<nrpoints; i++) { if (size[i] > pointsizerange[1] || size[i] < pointsizerange[0]) { printf("PTB-ERROR: You requested a point size of %f units, which is not in the range (%f to %f) supported by your graphics hardware.\n", size[i], pointsizerange[0], pointsizerange[1]); PsychErrorExitMsg(PsychError_user, "Unsupported point size requested in Screen('DrawDots')."); } // Setup point size for this point: glPointSize(size[i]); // Render point: glDrawArrays(GL_POINTS, i, 1); } } // Disable fast rendering of arrays: glDisableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_DOUBLE, 0, NULL); if (usecolorvector) PsychSetupVertexColorArrays(windowRecord, FALSE, 0, NULL, NULL); // Restore old matrix from backup copy, undoing the global translation: glPopMatrix(); // turn off antialiasing again if(idot_type) glDisable(GL_POINT_SMOOTH); // Reset pointsize to 1.0 glPointSize(1); // Mark end of drawing op. This is needed for single buffered drawing: PsychFlushGL(windowRecord); //All psychfunctions require this. return(PsychError_none); }
/* ** GL_SetDefaultState */ void GL_SetDefaultState( void ) { glClearDepth( 1.0f ); glCullFace( GL_FRONT ); glColor4f( 1, 1, 1, 1 ); // initialize downstream texture unit if we're running // in a multitexture environment if ( GLEW_ARB_multitexture ) { GL_SelectTexture( 1 ); GL_TextureMode( r_textureMode->string ); GL_TextureAnisotropy( r_textureAnisotropy->value ); GL_TexEnv( GL_MODULATE ); glDisable( GL_TEXTURE_2D ); GL_SelectTexture( 0 ); } glEnable( GL_TEXTURE_2D ); GL_TextureMode( r_textureMode->string ); GL_TextureAnisotropy( r_textureAnisotropy->value ); GL_TexEnv( GL_MODULATE ); glShadeModel( GL_SMOOTH ); glDepthFunc( GL_LEQUAL ); // the vertex array is always enabled, but the color and texture // arrays are enabled and disabled around the compiled vertex array call glEnableClientState( GL_VERTEX_ARRAY ); // // make sure our GL state vector is set correctly // glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE; glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); glDepthMask( GL_TRUE ); glDisable( GL_DEPTH_TEST ); glEnable( GL_SCISSOR_TEST ); glDisable( GL_CULL_FACE ); glDisable( GL_BLEND ); //----(SA) added. #if 0 // ATI pn_triangles if ( GLEW_ATI_pn_triangles ) { int maxtess; // get max supported tesselation glGetIntegerv( GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI, ( GLint * ) &maxtess ); #ifdef __MACOS__ glConfig.ATIMaxTruformTess = 7; #else glConfig.ATIMaxTruformTess = maxtess; #endif // cap if necessary if ( r_ati_truform_tess->value > maxtess ) { ri.Cvar_Set( "r_ati_truform_tess", va( "%d", maxtess ) ); } // set Wolf defaults glPNTrianglesfATI( GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, r_ati_truform_tess->value ); } #endif if ( glConfig.anisotropicAvailable ) { float maxAnisotropy; glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy ); glConfig.maxAnisotropy = maxAnisotropy; // set when rendering // glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, glConfig.maxAnisotropy); } //----(SA) end }
void OnInit() { GL_CHECK_ERRORS //generate the checker texture GLubyte data[128][128]={0}; for(int j=0;j<128;j++) { for(int i=0;i<128;i++) { data[i][j]=(i<=64 && j<=64 || i>64 && j>64 )?255:0; } } //generate texture object glGenTextures(1, &checkerTextureID); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, checkerTextureID); //set texture parameters glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); GL_CHECK_ERRORS //set maximum aniostropy setting GLfloat largest_supported_anisotropy; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_supported_anisotropy); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_supported_anisotropy); //set mipmap base and max level glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4); //allocate texture object glTexImage2D(GL_TEXTURE_2D,0,GL_RED, 128, 128, 0, GL_RED, GL_UNSIGNED_BYTE, data); //generate mipmaps glGenerateMipmap(GL_TEXTURE_2D); GL_CHECK_ERRORS //create a textured plane object checker_plane = new Graphics::CTexturedPlane(); GL_CHECK_ERRORS //setup camera //setup the camera position and look direction Vector3 p = Vector3(5, 5, 5); cam.SetPosition(p); Vector3 look(p); look.normalize(); //rotate the camera for proper orientation float yaw = glm::degrees(float(atan2(look.z, look.x)+Math::M_PI)); float pitch = glm::degrees(asin(look.y)); rX = yaw; rY = pitch; cam.Rotate(rX,rY,0); std::cout << "initialization completed" << std::endl; }
void OpenGLRender::blitText(IND_Font *pFo, char *pText, int pX, int pY, int pOffset, int pLineSpacing, float pScaleX, float pScaleY, BYTE pR, BYTE pG, BYTE pB, BYTE pA, BYTE pFadeR, BYTE pFadeG, BYTE pFadeB, BYTE pFadeA, IND_Filter pLinearFilter, IND_BlendingType pSo, IND_BlendingType pDs, IND_Align pAlign) { // ----- Transform ----- bool correctParams = true; if(!pFo->getSurface()) { correctParams = false; } if (correctParams) { setTransform2d(pX, pY, 0, 0, 0, pScaleX, pScaleY, 0, 0, 0, 0, pFo->getSurface()->getWidthBlock(), pFo->getSurface()->getHeightBlock(), 0); setRainbow2d(pFo->_font._surface->getTypeInt(), 1, 0, 0, pLinearFilter, pR, pG, pB, pA, pFadeR, pFadeG, pFadeB, pFadeA, pSo, pDs); // ----- Drawing text ----- BYTE mChar1; BYTE mChar2; int mCont1 = 0; int mCont2 = 0; int mTranslationX = 0; int mTranslationY = 0; bool mErrorChar; // Char that doesn't exist int mSentencePos; int mLongActualSentence; GLfloat mLineTransform[16]; //Maintains a transform inside the entity coord system GLfloat mEntityTransform[16]; //Maintains transform for the whole entity coord system mCont1 = 0; mChar1 = pText [mCont1++]; //Store entity transform glGetFloatv(GL_MODELVIEW_MATRIX,mEntityTransform); //LOOP - Blit character by character while (mChar1 != 0) { // If it's a new line or it's the first line if (mChar1 == '\n' || mCont1 == 1) { // First line if (mCont1 == 1) { mSentencePos = 0; //Any other line } else { mSentencePos = mCont1; } // Set the alignment switch (pAlign) { case IND_CENTER: { mLongActualSentence = static_cast<int>(getLongInPixels(pFo, pText, mSentencePos, pOffset) * pScaleX); mTranslationX = (int)(mLongActualSentence / 2); break; } case IND_RIGHT: { mLongActualSentence = static_cast<int>(getLongInPixels(pFo, pText, mSentencePos, pOffset) * pScaleX); mTranslationX = (int)(mLongActualSentence); break; } case IND_LEFT: { break; } } //Load line transform matrix taking into account entity transform //This effectively resets transform to first character in the new line IND_Matrix transform; _math.matrix4DSetTranslation(transform, static_cast<float>(-mTranslationX), static_cast<float>(mTranslationY), 0.0f); transform.arrayRepresentation(mLineTransform); glLoadMatrixf(mEntityTransform); glMultMatrixf(mLineTransform); mTranslationY += static_cast<int>((pLineSpacing * pScaleY)); } //Was first new line or first line // It's a normal character if (mChar1 != '\n') { mErrorChar = 0; mCont2 = 0; mChar2 = pFo->getLetters() [mCont2++]._letter; // Seek its location in the bitmap while (mChar2 != mChar1 && mCont2 < pFo->getNumChars()) { mChar2 = pFo->getLetters() [mCont2++]._letter; } if (mCont2 == pFo->getNumChars()) mErrorChar = 1; mCont2--; if (!mErrorChar) { //#warning lookout //mvTransformPresetState(); //Need to preset transform state, as the blit operation will reset the state!!!! blitRegionSurface(pFo->getSurface(), pFo->getLetters() [mCont2]._offsetX + 1, pFo->getLetters() [mCont2]._offsetY + 1, pFo->getLetters() [mCont2]._widthChar - 1, pFo->getLetters() [mCont2]._heightChar - 1); } //Displacement of the character. //Displacement transform accumulates for every character in the line float charTranslateX = ((pFo->getLetters() [mCont2]._widthChar) + pOffset) * pScaleX; glTranslatef(charTranslateX,0.0f,0.0f); }//Was normal character // Advance one character mChar1 = pText [mCont1++]; }//LOOP END - Blit character by character } }
void LoadingObject::Draw() { // Enable depth testing if flag is set if(_depth) { glEnable(GL_DEPTH_TEST); glAlphaFunc (GL_GREATER, 0.1f); glEnable (GL_ALPHA_TEST); } else glDisable(GL_DEPTH_TEST); float zoom = _sx/2; float width = _sy; glLoadIdentity(); glTranslatef(0.0f, 0.0f, 0.0f); glRotatef(_rotX, 1, 0, 0); glRotatef(_rotY, 0, 1, 0); glRotatef(_rotZ, 0, 0, 1); float z = -4; glPushMatrix(); //push the matrix so that our translations only affect { glTranslatef(_x, _y, z); //translate the tile to where it should belong glColor4f(_color->r,_color->g,_color->b,_color->a); glPointSize(1); //glColor3f(0.0,1.0,1.0); glBegin(GL_LINES); { int num_segments = 200; for(int r = 10; r < 20; r++) for(int ii = 0; ii < num_segments; ii++) { bool found = false; if (_counter > 490) { _counter = 0; rot++; if (_open) _smax++; else _smax--; if (_smax == 51) _open = false; else if (_smax == 0) _open = true; } else { _counter++; } for (uint8 splint = 0; splint < _smax; splint++) { if (ii == 00+splint || ii == 50+splint || ii == 100+splint || ii == 150+splint) { found = true; break; } } if (found) continue; float theta = rot *2.0f * 3.1415926f * float(ii) / float(num_segments); //get the current angle float x = ((float)r/100) * cosf(theta); //calculate the x component float y = ((float)r/100) * sinf(theta); //calculate the y component glVertex2f(x + _x, y + _y); //output vertex } } glEnd(); } glGetFloatv (GL_MODELVIEW_MATRIX, _matrix); glPopMatrix(); //pop the matrix /* glEnable(GL_TEXTURE_2D); { glEnable(GL_BLEND); { glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_2D, _texture); //get the texture for the actual quad glPushMatrix(); //push the matrix so that our translations only affect { glTranslatef(_x, _y, z); //translate the tile to where it should belong glColor4f(_Colr,_Colg,_Colb,_Cola); glBegin(GL_QUADS); //begin drawing our quads { glTexCoord2d(0.0, 1.0); glVertex2d((-1.0) * width, 1.0); glTexCoord2d(1.0, 1.0); glVertex2d((1.0) * width, 1.0); glTexCoord2d(1.0, 0.0); glVertex2d((1.0) * width, 0.9); glTexCoord2d(0.0, 0.0); glVertex2d((-1.0) * width, 0.9); } glEnd(); } glGetFloatv (GL_MODELVIEW_MATRIX, _matrix); glPopMatrix(); //pop the matrix glPushMatrix(); //push the matrix so that our translations only affect { glTranslatef(_x, _y, z); glColor4f(1,1,1,1); glBegin(GL_QUADS); //begin drawing our quads { float width = 3; //TOP glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 1.0); glTexCoord2d(1.0, 1.0); glVertex2d(1.0*width, 1.0); glTexCoord2d(1.0, 0.0); glVertex2d(1.0*width, 0.99); glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.99); //Bottom glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 0.89); glTexCoord2d(1.0, 1.0); glVertex2d(1.0*width, 0.89); glTexCoord2d(1.0, 0.0); glVertex2d(1.0*width, 0.88); glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.88); //Left glTexCoord2d(0.0, 1.0); glVertex2d(-1.0*width, 0.99); glTexCoord2d(1.0, 1.0); glVertex2d(-0.99*width, 0.99); glTexCoord2d(1.0, 0.0); glVertex2d(-0.99*width, 0.88); glTexCoord2d(0.0, 0.0); glVertex2d(-1.0*width, 0.88); //Right glTexCoord2d(0.0, 1.0); glVertex2d(1.0*width, 0.99); glTexCoord2d(1.0, 1.0); glVertex2d(0.99*width, 0.99); glTexCoord2d(1.0, 0.0); glVertex2d(0.99*width, 0.88); glTexCoord2d(0.0, 0.0); glVertex2d(1.0*width, 0.88); } glEnd(); } glPopMatrix(); //pop the matrix } glDisable(GL_BLEND); } glDisable(GL_TEXTURE_2D);*/ if(_depth) { glDisable (GL_ALPHA_TEST) ; glDisable(GL_DEPTH_TEST); } }
bool checkGLState(GLenum pname, GLfloat value) { GLfloat f; glGetFloatv(pname, &f); return (f == value); }
void SGCanvasMouseHandler::OnMouse(wxMouseEvent& event) { vec3 cursor = canvas->GetWorldSpace(event.GetX(), event.GetY()); if (event.LeftDown()) { if (!event.ControlDown()) { Stop(); } vStart = cursor; memcpy((float*) &mStart, (float*) &xform, sizeof(xform)); startZoom = canvas->GetZoom(); vPrev = cursor; validStart = true; } else if (event.LeftUp() && validStart) { float theta = 180 * vInc.magnitude(); if (theta < -InertiaThreshold || theta > InertiaThreshold) { inertiaAxis = cross(vStart, cursor); if (inertiaAxis.magnitude()) { inertiaAxis.unitize(); inertiaTheta = theta; } } else if (!event.ControlDown()) { Stop(); } validStart = false; } else if (event.Moving() && event.LeftIsDown()) { if (!validStart) { vInc = vec3(0.0f, 0.0f, 0.0f); } else { if (event.ControlDown()) { float delta = cursor.y - vStart.y; if (delta) { canvas->SetZoom(startZoom + delta); canvas->Update(); } } else { float theta = 180 * (cursor - vStart).magnitude(); if (theta) { vec3 axis = cross(vStart, cursor); axis.unitize(); glLoadIdentity(); glRotatef(-theta, axis.x, axis.y, axis.z); glMultMatrixf((float*) &mStart); glGetFloatv(GL_MODELVIEW_MATRIX, (float*) &xform); canvas->Update(); } } vInc = cursor - vPrev; } vPrev = cursor; } // Right mouse button zooms. else if (event.RightDown()) { vStart = cursor; startZoom = canvas->GetZoom(); validStart = true; } else if (event.RightUp() && validStart) { validStart = false; } else if (event.Moving() && event.RightIsDown()) { if (validStart) { float delta = cursor.y - vStart.y; if (delta) { canvas->SetZoom(startZoom + delta); canvas->Update(); } } } event.Skip(); }
void Example::render() { float modelviewMatrix[16]; float projectionMatrix[16]; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); gluLookAt(m_CamX, m_CamY, m_CamZ, 0.0, 0.0, 0.0f, 0.0f, 1.0f, 0.0f); glRotatef(m_rotationAngle, 0, 1, 0); glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix); glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix); m_GLSLProgram->sendUniform4x4("projection_matrix", projectionMatrix); vector<float> normalMatrix = calculateNormalMatrix(modelviewMatrix); m_GLSLProgram->sendUniform3x3("normal_matrix", &normalMatrix[0]); m_GLSLProgram->sendUniform("material_ambient", 0.2f, 0.2f, 0.2f, 1.0f); m_GLSLProgram->sendUniform("material_diffuse", 0.8f, 0.8f, 0.8f, 1.0f); m_GLSLProgram->sendUniform("material_specular", 0.6f, 0.6f, 0.6f, 1.0f); m_GLSLProgram->sendUniform("material_emissive", 0.0f, 0.0f, 0.0f, 1.0f); m_GLSLProgram->sendUniform("lights[0].ambient", 0.0f, 0.0f, 0.0f, 1.0f); m_GLSLProgram->sendUniform("lights[0].diffuse", 1.0f, 1.0f, 1.0f, 1.0f); m_GLSLProgram->sendUniform("lights[0].specular", 1.0f, 1.0f, 1.0f, 1.0f); m_GLSLProgram->sendUniform("lights[0].constant_attenuation", 1.0f); m_GLSLProgram->sendUniform("lights[0].linear_attenuation", 0.0f); m_GLSLProgram->sendUniform("lights[0].quadratic_attenuation", 0.0001f); m_GLSLProgram->sendUniform("lights[0].position", 0.0f, 30.0f, 0, 1.0f); m_GLSLProgram->sendUniform("lights[1].ambient", 0.0f, 0.0f, 0.0f, 1.0f); m_GLSLProgram->sendUniform("lights[1].diffuse", 1.0f, 1.0f, 1.0f, 1.0f); m_GLSLProgram->sendUniform("lights[1].specular", 1.0f, 1.0f, 1.0f, 1.0f); m_GLSLProgram->sendUniform("lights[1].constant_attenuation", 1.0f); m_GLSLProgram->sendUniform("lights[1].linear_attenuation", 0.0f); m_GLSLProgram->sendUniform("lights[1].quadratic_attenuation", 0.0001f); m_GLSLProgram->sendUniform("lights[1].position", 41, 30.0f,41, 1.0f); m_GLSLProgram->sendUniform("lights[2].ambient", 0.0f, 0.0f, 0.0f, 1.0f); m_GLSLProgram->sendUniform("lights[2].diffuse", HackyRearLights, 0.0f, 0.0f, HackyRearLights); m_GLSLProgram->sendUniform("lights[2].specular", HackyRearLights, HackyRearLights, HackyRearLights, HackyRearLights); m_GLSLProgram->sendUniform("lights[2].constant_attenuation", 1.0f); m_GLSLProgram->sendUniform("lights[2].linear_attenuation", 0.0f); m_GLSLProgram->sendUniform("lights[2].quadratic_attenuation", 0.001f); m_GLSLProgram->sendUniform("lights[2].position", ModelBase->m_offsetX, ModelBase->m_offsetY,ModelBase->m_offsetZ - 10, 1.0f); m_GLSLProgram->sendUniform("lights[3].ambient", 0.0f, 0.0f, 0.0f, 1.0f); m_GLSLProgram->sendUniform("lights[3].diffuse", HackyFrontLights, HackyFrontLights, HackyFrontLights, HackyFrontLights); m_GLSLProgram->sendUniform("lights[3].specular", HackyFrontLights, HackyFrontLights, HackyFrontLights, HackyFrontLights); m_GLSLProgram->sendUniform("lights[3].constant_attenuation", 1.0f); m_GLSLProgram->sendUniform("lights[3].linear_attenuation", 0.0f); m_GLSLProgram->sendUniform("lights[3].quadratic_attenuation", 0.001f); m_GLSLProgram->sendUniform("lights[3].position", ModelBase->m_offsetX, ModelBase->m_offsetY,ModelBase->m_offsetZ + 10, 1.0f); Models[6]->Draw(m_GLSLProgram); glBindTexture(GL_TEXTURE_2D, m_BaseTexID); m_GLSLProgram->sendUniform("texture0", 0); Models[0]->Draw(m_GLSLProgram); }
void display(void) { /* * save the viewing transform by saving a copy of the * modelview matrix at the right place, then undo the * rotation by calling calcMatrix() at the right time to * billboard the tree. Billboarding should only happen * if the billboard variable is not zero. */ float mat[16]; glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glLoadIdentity(); gluLookAt(-sinf(RAD(rotx))*5.5, transy, cosf(RAD(rotx))*5.5, 0. ,0. ,0., 0. ,1. ,0.); /* save the viewing tranform */ glGetFloatv(GL_MODELVIEW_MATRIX, mat); /* change the brightness of the flame light */ glLightfv(GL_LIGHT0, GL_DIFFUSE, &firelight[flames * 4]); /* ground */ glDisable(GL_TEXTURE_2D); glCallList(GROUND); glPushMatrix(); glTranslatef(0.f, 0.f, -transx); /* base of flame */ glCallList(FLAME_BASE); /* undo the rotation in the viewing transform */ if (billboard) calcMatrix(); /* flame polygon */ /* * position the flame light in the center of the flame polygon * turn off lighting, turn on texturing, bind the proper flame * texture, and draw the flame polygon. */ glLightfv(GL_LIGHT0, GL_POSITION, lightpos); glDisable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, flames); glColor4f(1.f, 1.f, 1.f, 1.f); glBegin(GL_POLYGON); glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, -1.0); glTexCoord2f(1.0, 0.0); glVertex2f(1.0, -1.0); glTexCoord2f(1.0, 1.0); glVertex2f(1.0, 1.0); glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, 1.0); glEnd(); glPopMatrix(); /* turn lighting back on */ glEnable(GL_LIGHTING); glutSwapBuffers(); }
void GLTexture_setImage(void * selfPtr, GLint mipmapLevel, GLsizei width, GLsizei height, unsigned int bytesPerRow, void * bitmapData) { GLTexture * self = selfPtr; if (self->textureName == 0) { glGenTextures(1, &self->textureName); } self->pixelWidth = width; self->pixelHeight = height; glBindTexture(GL_TEXTURE_2D, self->textureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, self->wrapS); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, self->wrapT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, self->magFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, self->minFilter); #if defined(GL_EXT_texture_filter_anisotropic) && GL_EXT_texture_filter_anisotropic if (self->anisotropicFilter) { GLfloat maxAnisotropy; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy); } #endif if (bytesPerRow % 4 == 0) { glPixelStorei(GL_UNPACK_ALIGNMENT, 4); } else if (bytesPerRow % 2 == 0) { glPixelStorei(GL_UNPACK_ALIGNMENT, 2); } else { glPixelStorei(GL_UNPACK_ALIGNMENT, 1); } #if !TARGET_OPENGL_ES if (self->autoMipmap) { switch (GLGraphics_getOpenGLAPIVersion()) { case GL_API_VERSION_DESKTOP_1: case GL_API_VERSION_DESKTOP_2: case GL_API_VERSION_DESKTOP_3: glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); break; default: break; } } #endif glTexImage2D(GL_TEXTURE_2D, mipmapLevel, self->bitmapDataFormat, width, height, 0, self->bitmapDataFormat, self->bitmapDataType, bitmapData); #if TARGET_OPENGL_ES if (self->autoMipmap) { switch (GLGraphics_getOpenGLAPIVersion()) { case GL_API_VERSION_ES1: glGenerateMipmapOES(GL_TEXTURE_2D); break; case GL_API_VERSION_ES2: glGenerateMipmap(GL_TEXTURE_2D); break; default: break; } } #endif }
MeshRenderProcessorGLSR::MeshRenderProcessorGLSR() : Processor() , inport_("geometryInport") //, imageInport_("imageInport") , meshName_("meshName") , outport_("imageOutport") //,DataFormatBase::get(DataFormatId::UInt16)) //, declarationsOutport_("declarationsOutport") , sceneDescOutport_("sceneDescriptionOutport") , camera_("camera", "Camera") , centerViewOnGeometry_("centerView", "Center view on geometry") , setNearFarPlane_("setNearFarPlane", "Calculate Near and Far Plane") , resetViewParams_("resetView", "Reset Camera") , trackball_(&camera_) , overrideColorBuffer_("overrideColorBuffer", "Override Color Buffer", false, InvalidationLevel::InvalidResources) , overrideColor_("overrideColor", "Override Color", vec4(0.75f, 0.75f, 0.75f, 1.0f), vec4(0.0f), vec4(1.0f)) , geomProperties_("geometry", "Geometry Rendering Properties") , cullFace_("cullFace", "Cull Face") , polygonMode_("polygonMode", "Polygon Mode") , renderPointSize_("renderPointSize", "Point Size", 1.0f, 0.001f, 15.0f, 0.001f) , renderLineWidth_("renderLineWidth", "Line Width", 1.0f, 0.001f, 15.0f, 0.001f) , enableDepthTest_("enableDepthTest_", "Enable Depth Test", true) , lightingProperty_("lighting", "Lighting", &camera_) , layers_("layers", "Layers (max 8)") , fragcolorLayer_("fragcolorLayer", "Frag Color", true, InvalidationLevel::InvalidResources) , cameraDirLayer_("cameraDirLayer", "Camera Direction", false, InvalidationLevel::InvalidResources) , normalsLayer_("normalsLayer", "Normals (World Space)", false, InvalidationLevel::InvalidResources) , lightDirLayer_("lightDirLayer", "Light Direction", false, InvalidationLevel::InvalidResources) , thresholdLayer_("thresholdLayer", "Silhouette Threshold", false, InvalidationLevel::InvalidResources) , thresholdDepthLayer_("thresholdDepthLayer", "Depth Threshold", false, InvalidationLevel::InvalidResources) , materialColLayer_("materialColor", "Material Specular Color", false, InvalidationLevel::InvalidResources) , lightSpecColLayer_("lightSpecularColor", "Light Specular Color", false, InvalidationLevel::InvalidResources) , shininessLayer_("shininess", "Specular Shininess Factor", false, InvalidationLevel::InvalidResources) , debugval1Layer_("debugval1Layer", "Debug Val 1", false, InvalidationLevel::InvalidResources) , debugval2Layer_("debugval2Layer", "Debug Val 2", false, InvalidationLevel::InvalidResources) // , colorLayer_("colorLayer", "Color", true, InvalidationLevel::InvalidResources) // , texCoordLayer_("texCoordLayer", "Texture Coordinates", false, // InvalidationLevel::InvalidResources) // , viewNormalsLayer_("viewNormalsLayer", "View Normals", false, // InvalidationLevel::InvalidResources) // , worldPosLayer_("worldPosLayer", "World Position Coordinates", false, // InvalidationLevel::InvalidResources) // , unnormalizedNormalsLayer_("notnormalizedNormalsLayer", "Normals (not normalised)", false, // InvalidationLevel::InvalidResources) // , fragDepthLayer_("fragDepthLayer", "Frag Depth", false, // InvalidationLevel::InvalidResources) // , viewNormalsNotLayer_("viewNormalsNotLayer", "View Normals (nor normalised)", false, // InvalidationLevel::InvalidResources) // , lightColorLayer_("lightColorLayer", "Light Color", false, InvalidationLevel::InvalidResources) //, layerDec_(std::make_shared<Declarations>()) , sceneDesc_(std::make_shared<SceneDescription>()) , shader_("silhouette.vert", "silhouette.frag", false) { addPort(inport_); //addPort(imageInport_); addPort(meshName_); addPort(outport_); //addPort(declarationsOutport_); addPort(sceneDescOutport_); //declarationsOutport_.setData(layerDec_); sceneDescOutport_.setData(sceneDesc_); // imageInport_.setOptional(true); addProperty(lightingProperty_); addProperty(layers_); layers_.addProperty(fragcolorLayer_); layers_.addProperty(normalsLayer_); layers_.addProperty(cameraDirLayer_); layers_.addProperty(lightDirLayer_); layers_.addProperty(thresholdLayer_); layers_.addProperty(thresholdDepthLayer_); layers_.addProperty(materialColLayer_); layers_.addProperty(lightSpecColLayer_); layers_.addProperty(shininessLayer_); //layers_.addProperty(colorLayer_); //layers_.addProperty(texCoordLayer_); //layers_.addProperty(viewNormalsLayer_); //layers_.addProperty(worldPosLayer_); //layers_.addProperty(unnormalizedNormalsLayer_); //layers_.addProperty(fragDepthLayer_); //layers_.addProperty(viewNormalsNotLayer_); //layers_.addProperty(lightColorLayer_); layers_.addProperty(debugval1Layer_); layers_.addProperty(debugval2Layer_); addProperty(camera_); centerViewOnGeometry_.onChange(this, &MeshRenderProcessorGLSR::centerViewOnGeometry); addProperty(centerViewOnGeometry_); setNearFarPlane_.onChange(this, &MeshRenderProcessorGLSR::setNearFarPlane); addProperty(setNearFarPlane_); resetViewParams_.onChange([this]() { camera_.resetCamera(); }); addProperty(resetViewParams_); outport_.addResizeEventListener(&camera_); inport_.onChange(this, &MeshRenderProcessorGLSR::updateDrawers); //meshName_.onChange(this, &MeshRenderProcessorGLSR::setSceneDesc); LogInfo(outport_.getData()->getDataFormat()->getString()); cullFace_.addOption("culldisable", "Disable", GL_NONE); cullFace_.addOption("cullfront", "Front", GL_FRONT); cullFace_.addOption("cullback", "Back", GL_BACK); cullFace_.addOption("cullfrontback", "Front & Back", GL_FRONT_AND_BACK); cullFace_.set(GL_NONE); polygonMode_.addOption("polypoint", "Points", GL_POINT); polygonMode_.addOption("polyline", "Lines", GL_LINE); polygonMode_.addOption("polyfill", "Fill", GL_FILL); polygonMode_.set(GL_FILL); polygonMode_.onChange(this, &MeshRenderProcessorGLSR::changeRenderMode); geomProperties_.addProperty(cullFace_); geomProperties_.addProperty(polygonMode_); geomProperties_.addProperty(renderPointSize_); geomProperties_.addProperty(renderLineWidth_); geomProperties_.addProperty(enableDepthTest_); geomProperties_.addProperty(overrideColorBuffer_); geomProperties_.addProperty(overrideColor_); overrideColor_.setSemantics(PropertySemantics::Color); overrideColor_.setVisible(false); overrideColorBuffer_.onChange([&]() { overrideColor_.setVisible(overrideColorBuffer_.get()); }); float lineWidthRange[2]; float increment; glGetFloatv(GL_LINE_WIDTH_RANGE, lineWidthRange); glGetFloatv(GL_LINE_WIDTH_GRANULARITY, &increment); renderLineWidth_.setMinValue(lineWidthRange[0]); renderLineWidth_.setMaxValue(lineWidthRange[1]); renderLineWidth_.setIncrement(increment); renderLineWidth_.setVisible(false); renderPointSize_.setVisible(false); addProperty(geomProperties_); addProperty(trackball_); setAllPropertiesCurrentStateAsDefault(); }
void glaDrawPixelsSafe(float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect) { float xzoom = glaGetOneFloat(GL_ZOOM_X); float yzoom = glaGetOneFloat(GL_ZOOM_Y); /* The pixel space coordinate of the intersection of * the [zoomed] image with the origin. */ float ix = -x / xzoom; float iy = -y / yzoom; /* The maximum pixel amounts the image can be cropped * at the lower left without exceeding the origin. */ int off_x = floor(max_ff(ix, 0.0f)); int off_y = floor(max_ff(iy, 0.0f)); /* The zoomed space coordinate of the raster position * (starting at the lower left most unclipped pixel). */ float rast_x = x + off_x * xzoom; float rast_y = y + off_y * yzoom; GLfloat scissor[4]; int draw_w, draw_h; /* Determine the smallest number of pixels we need to draw * before the image would go off the upper right corner. * * It may seem this is just an optimization but some graphics * cards (ATI) freak out if there is a large zoom factor and * a large number of pixels off the screen (probably at some * level the number of image pixels to draw is getting multiplied * by the zoom and then clamped). Making sure we draw the * fewest pixels possible keeps everyone mostly happy (still * fails if we zoom in on one really huge pixel so that it * covers the entire screen). */ glGetFloatv(GL_SCISSOR_BOX, scissor); draw_w = min_ii(img_w - off_x, ceil((scissor[2] - rast_x) / xzoom)); draw_h = min_ii(img_h - off_y, ceil((scissor[3] - rast_y) / yzoom)); if (draw_w > 0 && draw_h > 0) { int old_row_length = glaGetOneInteger(GL_UNPACK_ROW_LENGTH); /* Don't use safe RasterPos (slower) if we can avoid it. */ if (rast_x >= 0 && rast_y >= 0) { glRasterPos2f(rast_x, rast_y); } else { glaRasterPosSafe2f(rast_x, rast_y, 0, 0); } glPixelStorei(GL_UNPACK_ROW_LENGTH, row_w); if (format == GL_LUMINANCE || format == GL_RED) { if (type == GL_FLOAT) { float *f_rect = (float *)rect; glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y * row_w + off_x)); } else if (type == GL_INT || type == GL_UNSIGNED_INT) { int *i_rect = (int *)rect; glDrawPixels(draw_w, draw_h, format, type, i_rect + (off_y * row_w + off_x)); } } else { /* RGBA */ if (type == GL_FLOAT) { float *f_rect = (float *)rect; glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y * row_w + off_x) * 4); } else if (type == GL_UNSIGNED_BYTE) { unsigned char *uc_rect = (unsigned char *) rect; glDrawPixels(draw_w, draw_h, format, type, uc_rect + (off_y * row_w + off_x) * 4); } } glPixelStorei(GL_UNPACK_ROW_LENGTH, old_row_length); } }
static void print_limits(Q3ListViewItem *l1, const char * glExtensions, bool GetProcAddress) { /* TODO GL_SAMPLE_BUFFERS GL_SAMPLES GL_COMPRESSED_TEXTURE_FORMATS */ if (!glExtensions) return; struct token_name { GLuint type; // count and flags, !!! count must be <=2 for now GLenum token; const QString name; }; struct token_group { int count; int type; const token_name *group; const QString descr; const char *ext; }; Q3ListViewItem *l2 = NULL, *l3 = NULL; #if defined(PFNGLGETPROGRAMIVARBPROC) PFNGLGETPROGRAMIVARBPROC kcm_glGetProgramivARB = NULL; #endif #define KCMGL_FLOAT 128 #define KCMGL_PROG 256 #define KCMGL_COUNT_MASK(x) (x & 127) #define KCMGL_SIZE(x) (sizeof(x)/sizeof(x[0])) const struct token_name various_limits[] = { { 1, GL_MAX_LIGHTS, i18n("Max. number of light sources") }, { 1, GL_MAX_CLIP_PLANES, i18n("Max. number of clipping planes") }, { 1, GL_MAX_PIXEL_MAP_TABLE, i18n("Max. pixel map table size") }, { 1, GL_MAX_LIST_NESTING, i18n("Max. display list nesting level") }, { 1, GL_MAX_EVAL_ORDER, i18n("Max. evaluator order") }, { 1, GL_MAX_ELEMENTS_VERTICES, i18n("Max. recommended vertex count") }, { 1, GL_MAX_ELEMENTS_INDICES, i18n("Max. recommended index count") }, #ifdef GL_QUERY_COUNTER_BITS { 1, GL_QUERY_COUNTER_BITS, i18n("Occlusion query counter bits")}, #endif #ifdef GL_MAX_VERTEX_UNITS_ARB { 1, GL_MAX_VERTEX_UNITS_ARB, i18n("Max. vertex blend matrices") }, #endif #ifdef GL_MAX_PALETTE_MATRICES_ARB { 1, GL_MAX_PALETTE_MATRICES_ARB, i18n("Max. vertex blend matrix palette size") }, #endif {0,0,0} }; const struct token_name texture_limits[] = { { 1, GL_MAX_TEXTURE_SIZE, i18n("Max. texture size") }, { 1, GL_MAX_TEXTURE_UNITS_ARB, i18n("Num. of texture units") }, { 1, GL_MAX_3D_TEXTURE_SIZE, i18n("Max. 3D texture size") }, { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, i18n("Max. cube map texture size") }, #ifdef GL_MAX_RECTANGLE_TEXTURE_SIZE_NV { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, i18n("Max. rectangular texture size") }, #endif { 1 | KCMGL_FLOAT, GL_MAX_TEXTURE_LOD_BIAS_EXT, i18n("Max. texture LOD bias") }, { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, i18n("Max. anisotropy filtering level") }, { 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, i18n("Num. of compressed texture formats") }, {0,0,0} }; const struct token_name float_limits[] = { { 2 | KCMGL_FLOAT, GL_ALIASED_POINT_SIZE_RANGE, "ALIASED_POINT_SIZE_RANGE" }, { 2 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_RANGE, "SMOOTH_POINT_SIZE_RANGE" }, { 1 | KCMGL_FLOAT, GL_SMOOTH_POINT_SIZE_GRANULARITY,"SMOOTH_POINT_SIZE_GRANULARITY"}, { 2 | KCMGL_FLOAT, GL_ALIASED_LINE_WIDTH_RANGE, "ALIASED_LINE_WIDTH_RANGE" }, { 2 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_RANGE, "SMOOTH_LINE_WIDTH_RANGE" }, { 1 | KCMGL_FLOAT, GL_SMOOTH_LINE_WIDTH_GRANULARITY,"SMOOTH_LINE_WIDTH_GRANULARITY"}, {0,0,0} }; const struct token_name stack_depth[] = { { 1, GL_MAX_MODELVIEW_STACK_DEPTH, "MAX_MODELVIEW_STACK_DEPTH" }, { 1, GL_MAX_PROJECTION_STACK_DEPTH, "MAX_PROJECTION_STACK_DEPTH" }, { 1, GL_MAX_TEXTURE_STACK_DEPTH, "MAX_TEXTURE_STACK_DEPTH" }, { 1, GL_MAX_NAME_STACK_DEPTH, "MAX_NAME_STACK_DEPTH" }, { 1, GL_MAX_ATTRIB_STACK_DEPTH, "MAX_ATTRIB_STACK_DEPTH" }, { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "MAX_CLIENT_ATTRIB_STACK_DEPTH" }, { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "MAX_COLOR_MATRIX_STACK_DEPTH" }, #ifdef GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB { 1, GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB,"MAX_MATRIX_PALETTE_STACK_DEPTH"}, #endif {0,0,0} }; #ifdef GL_ARB_fragment_program const struct token_name arb_fp[] = { { 1, GL_MAX_TEXTURE_COORDS_ARB, "MAX_TEXTURE_COORDS" }, { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "MAX_TEXTURE_IMAGE_UNITS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "MAX_PROGRAM_ENV_PARAMETERS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "MAX_PROGRAM_LOCAL_PARAMETERS" }, { 1, GL_MAX_PROGRAM_MATRICES_ARB, "MAX_PROGRAM_MATRICES" }, { 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, "MAX_PROGRAM_MATRIX_STACK_DEPTH" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "MAX_PROGRAM_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_ALU_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_TEX_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_TEX_INDIRECTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB, "MAX_PROGRAM_TEMPORARIES" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB, "MAX_PROGRAM_PARAMETERS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB, "MAX_PROGRAM_ATTRIBS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "MAX_PROGRAM_NATIVE_TEMPORARIES" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "MAX_PROGRAM_NATIVE_PARAMETERS" }, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "MAX_PROGRAM_NATIVE_ATTRIBS" }, {0,0,0} }; #endif #ifdef GL_ARB_vertex_program const struct token_name arb_vp[] = { { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB,"MAX_PROGRAM_ENV_PARAMETERS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB,"MAX_PROGRAM_LOCAL_PARAMETERS"}, { 1, GL_MAX_VERTEX_ATTRIBS_ARB, "MAX_VERTEX_ATTRIBS"}, { 1, GL_MAX_PROGRAM_MATRICES_ARB,"MAX_PROGRAM_MATRICES"}, { 1, GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB,"MAX_PROGRAM_MATRIX_STACK_DEPTH"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_INSTRUCTIONS_ARB,"MAX_PROGRAM_INSTRUCTIONS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_TEMPORARIES_ARB,"MAX_PROGRAM_TEMPORARIES"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_PARAMETERS_ARB,"MAX_PROGRAM_PARAMETERS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ATTRIBS_ARB,"MAX_PROGRAM_ATTRIBS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB,"MAX_PROGRAM_ADDRESS_REGISTERS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB,"MAX_PROGRAM_NATIVE_INSTRUCTIONS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB,"MAX_PROGRAM_NATIVE_TEMPORARIES"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB,"MAX_PROGRAM_NATIVE_PARAMETERS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB,"MAX_PROGRAM_NATIVE_ATTRIBS"}, { 1 | KCMGL_PROG, GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB ,"MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS"}, {0,0,0} }; #endif #ifdef GL_ARB_vertex_shader const struct token_name arb_vs[] = { { 1, GL_MAX_VERTEX_ATTRIBS_ARB,"MAX_VERTEX_ATTRIBS"}, { 1, GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,"MAX_VERTEX_UNIFORM_COMPONENTS"}, { 1, GL_MAX_VARYING_FLOATS_ARB,"MAX_VARYING_FLOATS"}, { 1, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,"MAX_COMBINED_TEXTURE_IMAGE_UNITS"}, { 1, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,"MAX_VERTEX_TEXTURE_IMAGE_UNITS"}, { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"}, { 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"}, {0,0,0} }; #endif #ifdef GL_ARB_fragment_shader const struct token_name arb_fs[] = { { 1, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,"MAX_FRAGMENT_UNIFORM_COMPONENTS"}, { 1, GL_MAX_TEXTURE_IMAGE_UNITS_ARB,"MAX_TEXTURE_IMAGE_UNITS"}, { 1, GL_MAX_TEXTURE_COORDS_ARB,"MAX_TEXTURE_COORDS"}, {0,0,0} }; #endif const struct token_name frame_buffer_props[] = { { 2, GL_MAX_VIEWPORT_DIMS, i18n("Max. viewport dimensions") }, { 1, GL_SUBPIXEL_BITS, i18n("Subpixel bits") }, { 1, GL_AUX_BUFFERS, i18n("Aux. buffers")}, {0,0,0} }; const struct token_group groups[] = { {KCMGL_SIZE(frame_buffer_props), 0, frame_buffer_props, i18n("Frame buffer properties"), NULL}, {KCMGL_SIZE(various_limits), 0, texture_limits, i18n("Texturing"), NULL}, {KCMGL_SIZE(various_limits), 0, various_limits, i18n("Various limits"), NULL}, {KCMGL_SIZE(float_limits), 0, float_limits, i18n("Points and lines"), NULL}, {KCMGL_SIZE(stack_depth), 0, stack_depth, i18n("Stack depth limits"), NULL}, #ifdef GL_ARB_vertex_program {KCMGL_SIZE(arb_vp), GL_VERTEX_PROGRAM_ARB, arb_vp, "ARB_vertex_program", "GL_ARB_vertex_program"}, #endif #ifdef GL_ARB_fragment_program {KCMGL_SIZE(arb_fp), GL_FRAGMENT_PROGRAM_ARB, arb_fp, "ARB_fragment_program", "GL_ARB_fragment_program"}, #endif #ifdef GL_ARB_vertex_shader {KCMGL_SIZE(arb_vs), 0, arb_vs, "ARB_vertex_shader", "GL_ARB_vertex_shader"}, #endif #ifdef GL_ARB_fragment_shader {KCMGL_SIZE(arb_fs), 0, arb_fs, "ARB_fragment_shader", "GL_ARB_fragment_shader"}, #endif }; #if defined(GLX_ARB_get_proc_address) && defined(PFNGLGETPROGRAMIVARBPROC) if (GetProcAddress && strstr(glExtensions, "GL_ARB_vertex_program")) kcm_glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) glXGetProcAddressARB((const GLubyte *)"glGetProgramivARB"); #endif for (uint i = 0; i<KCMGL_SIZE(groups); i++) { if (groups[i].ext && !strstr(glExtensions, groups[i].ext)) continue; if (l2) l2 = new Q3ListViewItem(l1, l2, groups[i].descr); else l2 = new Q3ListViewItem(l1, groups[i].descr); l3 = NULL; const struct token_name *cur_token; for (cur_token = groups[i].group; cur_token->type; cur_token++) { bool tfloat = cur_token->type & KCMGL_FLOAT; int count = KCMGL_COUNT_MASK(cur_token->type); GLint max[2]={0,0}; GLfloat fmax[2]={0.0,0.0}; #if defined(PFNGLGETPROGRAMIVARBPROC) && defined(GL_ARB_vertex_program) bool tprog = cur_token->type & KCMGL_PROG; if (tprog && kcm_glGetProgramivARB) kcm_glGetProgramivARB(groups[i].type, cur_token->token, max); else #endif if (tfloat) glGetFloatv(cur_token->token, fmax); else glGetIntegerv(cur_token->token, max); if (glGetError() == GL_NONE) { QString s; if (!tfloat && count == 1) s = QString::number(max[0]); else if (!tfloat && count == 2) s = QString("%1, %2").arg(max[0]).arg(max[1]); else if (tfloat && count == 2) s = QString("%1 - %2").arg(fmax[0],0,'f',6).arg(fmax[1],0,'f',6); else if (tfloat && count == 1) s = QString::number(fmax[0],'f',6); if (l3) l3 = new Q3ListViewItem(l2, l3, cur_token->name, s); else l3 = new Q3ListViewItem(l2, cur_token->name, s); } } } }
/* ============= R_SetupGL ============= */ void R_SetupGL (void) { float screenaspect; float yfov; int i; extern int glwidth, glheight; int x, x2, y2, y, w, h; // // set up viewpoint // glMatrixMode(GL_PROJECTION); glLoadIdentity (); x = r_refdef.vrect.x * glwidth/vid.width; x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * glwidth/vid.width; y = (vid.height-r_refdef.vrect.y) * glheight/vid.height; y2 = (vid.height - (r_refdef.vrect.y + r_refdef.vrect.height)) * glheight/vid.height; // fudge around because of frac screen scale if (x > 0) x--; if (x2 < glwidth) x2++; if (y2 < 0) y2--; if (y < glheight) y++; w = x2 - x; h = y - y2; if (envmap) { x = y2 = 0; w = h = 256; } glViewport (glx + x, gly + y2, w, h); screenaspect = (float)r_refdef.vrect.width/r_refdef.vrect.height; // yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI; MYgluPerspective (r_refdef.fov_y, screenaspect, 4, 4096); if (mirror) { if (mirror_plane->normal[2]) glScalef (1, -1, 1); else glScalef (-1, 1, 1); glCullFace(GL_BACK); } else glCullFace(GL_FRONT); glMatrixMode(GL_MODELVIEW); glLoadIdentity (); glRotatef (-90, 1, 0, 0); // put Z going up glRotatef (90, 0, 0, 1); // put Z going up glRotatef (-r_refdef.viewangles[2], 1, 0, 0); glRotatef (-r_refdef.viewangles[0], 0, 1, 0); glRotatef (-r_refdef.viewangles[1], 0, 0, 1); glTranslatef (-r_refdef.vieworg[0], -r_refdef.vieworg[1], -r_refdef.vieworg[2]); glGetFloatv (GL_MODELVIEW_MATRIX, r_world_matrix); // // set drawing parms // if (gl_cull.value) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); glEnable(GL_DEPTH_TEST); }
void OpenGL3Driver::setup_caps(DriverRenderingCapabilities& caps) { glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &caps.max_anisotropic_level); }
void C3dCamera::ExtractFrustum() { // Extracts The Current View m_fFrustum Plane Equations float proj[16]; // For Grabbing The PROJECTION Matrix float modl[16]; // For Grabbing The MODELVIEW Matrix double clip[16]; // Result Of Concatenating PROJECTION and MODELVIEW double t; // Temporary Work Variable glGetFloatv( GL_PROJECTION_MATRIX, proj ); // Grab The Current PROJECTION Matrix glGetFloatv( GL_MODELVIEW_MATRIX, modl ); // Grab The Current MODELVIEW Matrix // Concatenate (Multiply) The Two Matricies clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12]; clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13]; clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14]; clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15]; clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12]; clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13]; clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14]; clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15]; clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12]; clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13]; clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14]; clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15]; clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12]; clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13]; clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14]; clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15]; // Extract the RIGHT clipping plane m_fFrustum[0][0] = clip[ 3] - clip[ 0]; m_fFrustum[0][1] = clip[ 7] - clip[ 4]; m_fFrustum[0][2] = clip[11] - clip[ 8]; m_fFrustum[0][3] = clip[15] - clip[12]; // Normalize it t = (double) sqrt( m_fFrustum[0][0] * m_fFrustum[0][0] + m_fFrustum[0][1] * m_fFrustum[0][1] + m_fFrustum[0][2] * m_fFrustum[0][2] ); m_fFrustum[0][0] /= t; m_fFrustum[0][1] /= t; m_fFrustum[0][2] /= t; m_fFrustum[0][3] /= t; // Extract the LEFT clipping plane m_fFrustum[1][0] = clip[ 3] + clip[ 0]; m_fFrustum[1][1] = clip[ 7] + clip[ 4]; m_fFrustum[1][2] = clip[11] + clip[ 8]; m_fFrustum[1][3] = clip[15] + clip[12]; // Normalize it t = (double) sqrt( m_fFrustum[1][0] * m_fFrustum[1][0] + m_fFrustum[1][1] * m_fFrustum[1][1] + m_fFrustum[1][2] * m_fFrustum[1][2] ); m_fFrustum[1][0] /= t; m_fFrustum[1][1] /= t; m_fFrustum[1][2] /= t; m_fFrustum[1][3] /= t; // Extract the BOTTOM clipping plane m_fFrustum[2][0] = clip[ 3] + clip[ 1]; m_fFrustum[2][1] = clip[ 7] + clip[ 5]; m_fFrustum[2][2] = clip[11] + clip[ 9]; m_fFrustum[2][3] = clip[15] + clip[13]; // Normalize it t = (double) sqrt( m_fFrustum[2][0] * m_fFrustum[2][0] + m_fFrustum[2][1] * m_fFrustum[2][1] + m_fFrustum[2][2] * m_fFrustum[2][2] ); m_fFrustum[2][0] /= t; m_fFrustum[2][1] /= t; m_fFrustum[2][2] /= t; m_fFrustum[2][3] /= t; // Extract the TOP clipping plane m_fFrustum[3][0] = clip[ 3] - clip[ 1]; m_fFrustum[3][1] = clip[ 7] - clip[ 5]; m_fFrustum[3][2] = clip[11] - clip[ 9]; m_fFrustum[3][3] = clip[15] - clip[13]; // Normalize it t = sqrt( m_fFrustum[3][0] * m_fFrustum[3][0] + m_fFrustum[3][1] * m_fFrustum[3][1] + m_fFrustum[3][2] * m_fFrustum[3][2] ); m_fFrustum[3][0] /= t; m_fFrustum[3][1] /= t; m_fFrustum[3][2] /= t; m_fFrustum[3][3] /= t; // Extract the FAR clipping plane m_fFrustum[4][0] = clip[ 3] - clip[ 2]; m_fFrustum[4][1] = clip[ 7] - clip[ 6]; m_fFrustum[4][2] = clip[11] - clip[10]; m_fFrustum[4][3] = clip[15] - clip[14]; // Normalize it t = sqrt( m_fFrustum[4][0] * m_fFrustum[4][0] + m_fFrustum[4][1] * m_fFrustum[4][1] + m_fFrustum[4][2] * m_fFrustum[4][2] ); m_fFrustum[4][0] /= t; m_fFrustum[4][1] /= t; m_fFrustum[4][2] /= t; m_fFrustum[4][3] /= t; // Extract the NEAR clipping plane. m_fFrustum[5][0] = clip[ 3] + clip[ 2]; m_fFrustum[5][1] = clip[ 7] + clip[ 6]; m_fFrustum[5][2] = clip[11] + clip[10]; m_fFrustum[5][3] = clip[15] + clip[14]; // Normalize it t = (double) sqrt( m_fFrustum[5][0] * m_fFrustum[5][0] + m_fFrustum[5][1] * m_fFrustum[5][1] + m_fFrustum[5][2] * m_fFrustum[5][2] ); m_fFrustum[5][0] /= t; m_fFrustum[5][1] /= t; m_fFrustum[5][2] /= t; m_fFrustum[5][3] /= t; }
/// <summary> /// Execute http get request /// </summary> /// <param name="idstr">OpenGL enum as string</param> /// <param name="id">OpenGL enum to query</param> /// <param name="type">Internal OpenGL enum type (glint, glstring)</param> /// <param name="dim">No of dimensions to query</param> void capsGroup::addCapability(string idstr, GLenum id, string type, int dim) { string errorValue = "n/a"; // Clear last OpenGL error GLint dummyError = glGetError(); if (type == "glint") { GLint* intVal; intVal = new GLint[dim]; glGetIntegerv(id, intVal); string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } valString += to_string(intVal[i]); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } delete[] intVal; } if (type == "glint64") { GLint64* intVal; intVal = new GLint64[dim]; glGetInteger64v(id, intVal); string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } valString += to_string(intVal[i]); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } delete[] intVal; } if (type == "glintindex") { GLint intVal; string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } glGetIntegeri_v(id, i, &intVal); valString += to_string(intVal); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } } if (type == "glintfragmentprogram") { GLint* intVal; intVal = new GLint[dim]; glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, id, intVal); string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } valString += to_string(intVal[i]); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } delete[] intVal; } if (type == "glintvertexprogram") { GLint* intVal; intVal = new GLint[dim]; glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, id, intVal); string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } valString += to_string(intVal[i]); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } delete[] intVal; } if (type == "glfloat") { GLfloat* floatVal; floatVal = new GLfloat[dim]; glGetFloatv(id, floatVal); string valString = ""; for (int i = 0; i < dim; i++) { if (i > 0) { valString += " ,"; } valString += to_string(floatVal[i]); } GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = errorValue; } delete[] floatVal; } if (type == "glstring") { string valString = reinterpret_cast<const char*>(glGetString(id)); GLint glerr = glGetError(); capabilities[idstr] = valString; if (glerr != GL_NO_ERROR) { capabilities[idstr] = ""; } } }
// JMQTODO: really need a platform-shared version of this nastiness bool GL_EXT_Init( ) { // Load extensions... // const char* pExtString = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)); gGLState.primMode = 0; U32 extBitMask = 0; // GL_EXT_paletted_texture if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_paletted_texture") != NULL) { extBitMask |= EXT_paletted_texture; gGLState.suppPalettedTexture = true; } else gGLState.suppPalettedTexture = false; // EXT_compiled_vertex_array if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_compiled_vertex_array") != NULL) { extBitMask |= EXT_compiled_vertex_array; gGLState.suppLockedArrays = true; } else { gGLState.suppLockedArrays = false; } // ARB_multitexture if (pExtString && dStrstr(pExtString, (const char*)"GL_ARB_multitexture") != NULL) { extBitMask |= ARB_multitexture; gGLState.suppARBMultitexture = true; } else { gGLState.suppARBMultitexture = false; } // EXT_blend_color if(pExtString && dStrstr(pExtString, (const char*)"GL_EXT_blend_color") != NULL) { extBitMask |= EXT_blend_color; gGLState.suppEXTblendcolor = true; } else { gGLState.suppEXTblendcolor = false; } // EXT_blend_minmax if(pExtString && dStrstr(pExtString, (const char*)"GL_EXT_blend_minmax") != NULL) { extBitMask |= EXT_blend_color; gGLState.suppEXTblendminmax = true; } else { gGLState.suppEXTblendminmax = false; } // EXT_fog_coord if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_fog_coord") != NULL) { extBitMask |= EXT_fog_coord; gGLState.suppFogCoord = true; } else { gGLState.suppFogCoord = false; } // EXT_texture_compression_s3tc if (pExtString && dStrstr(pExtString, (const char*)"GL_EXT_texture_compression_s3tc") != NULL) gGLState.suppS3TC = true; else gGLState.suppS3TC = false; // ARB_texture_compression if (pExtString && dStrstr(pExtString, (const char*)"GL_ARB_texture_compression") != NULL) { extBitMask |= ARB_texture_compression; gGLState.suppTextureCompression = true; } else { gGLState.suppTextureCompression = false; } // NV_vertex_array_range (not on *nix) gGLState.suppVertexArrayRange = false; // 3DFX_texture_compression_FXT1 if (pExtString && dStrstr(pExtString, (const char*)"3DFX_texture_compression_FXT1") != NULL) gGLState.suppFXT1 = true; else gGLState.suppFXT1 = false; if (!bindEXTFunctions(extBitMask)) Con::warnf("You are missing some OpenGL Extensions. You may experience rendering problems."); // Binary states, i.e., no supporting functions // EXT_packed_pixels // EXT_texture_env_combine // // dhc note: a number of these can have multiple matching 'versions', private, ext, and arb. gGLState.suppPackedPixels = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_packed_pixels") != NULL) : false; gGLState.suppTextureEnvCombine = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_env_combine") != NULL) : false; gGLState.suppEdgeClamp = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_edge_clamp") != NULL) : false; gGLState.suppEdgeClamp |= pExtString? (dStrstr(pExtString, (const char*)"GL_SGIS_texture_edge_clamp") != NULL) : false; gGLState.suppTexEnvAdd = pExtString? (dStrstr(pExtString, (const char*)"GL_ARB_texture_env_add") != NULL) : false; gGLState.suppTexEnvAdd |= pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_env_add") != NULL) : false; // Anisotropic filtering gGLState.suppTexAnisotropic = pExtString? (dStrstr(pExtString, (const char*)"GL_EXT_texture_filter_anisotropic") != NULL) : false; if (gGLState.suppTexAnisotropic) glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gGLState.maxAnisotropy); if (gGLState.suppARBMultitexture) glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gGLState.maxTextureUnits); else gGLState.maxTextureUnits = 1; // JMQ: vsync/swap interval skipped gGLState.suppSwapInterval = false; Con::printf("OpenGL Init: Enabled Extensions"); if (gGLState.suppARBMultitexture) Con::printf(" ARB_multitexture (Max Texture Units: %d)", gGLState.maxTextureUnits); if (gGLState.suppEXTblendcolor) Con::printf(" EXT_blend_color"); if (gGLState.suppEXTblendminmax) Con::printf(" EXT_blend_minmax"); if (gGLState.suppPalettedTexture) Con::printf(" EXT_paletted_texture"); if (gGLState.suppLockedArrays) Con::printf(" EXT_compiled_vertex_array"); if (gGLState.suppVertexArrayRange) Con::printf(" NV_vertex_array_range"); if (gGLState.suppTextureEnvCombine) Con::printf(" EXT_texture_env_combine"); if (gGLState.suppPackedPixels) Con::printf(" EXT_packed_pixels"); if (gGLState.suppFogCoord) Con::printf(" EXT_fog_coord"); if (gGLState.suppTextureCompression) Con::printf(" ARB_texture_compression"); if (gGLState.suppS3TC) Con::printf(" EXT_texture_compression_s3tc"); if (gGLState.suppFXT1) Con::printf(" 3DFX_texture_compression_FXT1"); if (gGLState.suppTexEnvAdd) Con::printf(" (ARB|EXT)_texture_env_add"); if (gGLState.suppTexAnisotropic) Con::printf(" EXT_texture_filter_anisotropic (Max anisotropy: %f)", gGLState.maxAnisotropy); if (gGLState.suppSwapInterval) Con::printf(" WGL_EXT_swap_control"); Con::warnf("OpenGL Init: Disabled Extensions"); if (!gGLState.suppARBMultitexture) Con::warnf(" ARB_multitexture"); if (!gGLState.suppEXTblendcolor) Con::warnf(" EXT_blend_color"); if (!gGLState.suppEXTblendminmax) Con::warnf(" EXT_blend_minmax"); if (!gGLState.suppPalettedTexture) Con::warnf(" EXT_paletted_texture"); if (!gGLState.suppLockedArrays) Con::warnf(" EXT_compiled_vertex_array"); if (!gGLState.suppVertexArrayRange) Con::warnf(" NV_vertex_array_range"); if (!gGLState.suppTextureEnvCombine) Con::warnf(" EXT_texture_env_combine"); if (!gGLState.suppPackedPixels) Con::warnf(" EXT_packed_pixels"); if (!gGLState.suppFogCoord) Con::warnf(" EXT_fog_coord"); if (!gGLState.suppTextureCompression) Con::warnf(" ARB_texture_compression"); if (!gGLState.suppS3TC) Con::warnf(" EXT_texture_compression_s3tc"); if (!gGLState.suppFXT1) Con::warnf(" 3DFX_texture_compression_FXT1"); if (!gGLState.suppTexEnvAdd) Con::warnf(" (ARB|EXT)_texture_env_add"); if (!gGLState.suppTexAnisotropic) Con::warnf(" EXT_texture_filter_anisotropic"); if (!gGLState.suppSwapInterval) Con::warnf(" WGL_EXT_swap_control"); Con::printf(" "); // Set some console variables: Con::setBoolVariable( "$FogCoordSupported", gGLState.suppFogCoord ); Con::setBoolVariable( "$TextureCompressionSupported", gGLState.suppTextureCompression ); Con::setBoolVariable( "$AnisotropySupported", gGLState.suppTexAnisotropic ); Con::setBoolVariable( "$PalettedTextureSupported", gGLState.suppPalettedTexture ); Con::setBoolVariable( "$SwapIntervalSupported", gGLState.suppSwapInterval ); if (!gGLState.suppPalettedTexture && Con::getBoolVariable("$pref::OpenGL::forcePalettedTexture",false)) { Con::setBoolVariable("$pref::OpenGL::forcePalettedTexture", false); Con::setBoolVariable("$pref::OpenGL::force16BitTexture", true); } return true; }
void ApplyShadowMaps (short nStartSeg, fix nEyeOffset, int nWindow) { static float mTexBiasf [] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f}; static float mPlanef [] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; static GLenum nTexCoord [] = {GL_S, GL_T, GL_R, GL_Q}; CFloatMatrix mProjection; CFloatMatrix mModelView; int i; CCamera *cameraP; #if 1 OglActiveTexture (GL_TEXTURE0, 0); glEnable (GL_TEXTURE_2D); glEnable (GL_TEXTURE_GEN_S); glEnable (GL_TEXTURE_GEN_T); glEnable (GL_TEXTURE_GEN_R); glEnable (GL_TEXTURE_GEN_Q); for (i = 0; i < 4; i++) glTexGeni (nTexCoord [i], GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); for (i = 0; i < 4; i++) glTexGenfv (nTexCoord [i], GL_EYE_PLANE, mPlanef + 4 * i); glGetFloatv (GL_PROJECTION_MATRIX, mProjection.Vec ()); glMatrixMode (GL_TEXTURE); for (i = 0, cameraP = gameData.render.shadows.shadowMaps; i < 1/*gameData.render.shadows.nShadowMaps*/; i++) { glBindTexture (GL_TEXTURE_2D, cameraP->FrameBuffer ().RenderBuffer ()); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glLoadMatrixf (mTexBiasf); glMultMatrixf (mProjection.Vec ()); CFixMatrix::Transpose (mModelView, cameraP->GetObject ()->info.position.mOrient); glMultMatrixf (mModelView.Vec ()); } glMatrixMode (GL_MODELVIEW); #endif RenderMine (nStartSeg, nEyeOffset, nWindow); #if 1 glMatrixMode (GL_TEXTURE); glLoadIdentity (); glMatrixMode (GL_MODELVIEW); glDisable (GL_TEXTURE_GEN_S); glDisable (GL_TEXTURE_GEN_T); glDisable (GL_TEXTURE_GEN_R); glDisable (GL_TEXTURE_GEN_Q); OglActiveTexture (GL_TEXTURE0, 0); glDisable (GL_TEXTURE_2D); #endif DestroyShadowMaps (); }