/* =============== GL_TextureMode =============== */ void GL_TextureMode( char *string ) { int i; image_t *glt; for (i=0 ; i< NUM_GL_MODES ; i++) { if ( !Q_strcasecmp( modes[i].name, string ) ) break; } if (i == NUM_GL_MODES) { VID_Printf (PRINT_ALL, "bad filter name\n"); return; } gl_filter_min = modes[i].minimize; gl_filter_max = modes[i].maximize; // change all the existing mipmap texture objects for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++) { if (glt->type != it_pic && glt->type != it_sky ) { GL_Bind (glt->texnum); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } } }
void RE_UploadCinematic( int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty ) { #if defined( USE_D3D10 ) // TODO #else GL_Bind( tr.scratchImage[ client ] ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cols != tr.scratchImage[ client ]->width || rows != tr.scratchImage[ client ]->height ) { tr.scratchImage[ client ]->width = tr.scratchImage[ client ]->uploadWidth = cols; tr.scratchImage[ client ]->height = tr.scratchImage[ client ]->uploadHeight = rows; qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER ); qglTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, colorBlack ); } else { if ( dirty ) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data ); } } GL_CheckErrors(); #endif }
/* =============== CreateDSTTex_ARB Create the texture which warps texture shaders =============== */ void CreateDSTTex_ARB (void) { unsigned char dist[DST_SIZE][DST_SIZE][4]; int x,y; srand(GetTickCount()); for (x=0; x<DST_SIZE; x++) for (y=0; y<DST_SIZE; y++) { dist[x][y][0] = rand()%255; dist[x][y][1] = rand()%255; dist[x][y][2] = rand()%48; dist[x][y][3] = rand()%48; } qglGenTextures(1,&dst_texture_ARB); qglBindTexture(GL_TEXTURE_2D, dst_texture_ARB); qglTexImage2D (GL_TEXTURE_2D, 0, 4, DST_SIZE, DST_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, dist); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); qglHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST); qglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); }
void R_SetDefaultState(void) { qglClearColor(1, 0, 0.5, 0.5); qglCullFace(GL_FRONT); qglEnable(GL_TEXTURE_2D); qglEnable(GL_ALPHA_TEST); qglAlphaFunc(GL_GREATER, 0.666); qglDisable(GL_DEPTH_TEST); qglDisable(GL_CULL_FACE); qglDisable(GL_BLEND); qglColor4f(1, 1, 1, 1); qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL); qglShadeModel(GL_FLAT); R_TextureMode(gl_texturemode->string); R_TextureAlphaMode(gl_texturealphamode->string); R_TextureSolidMode(gl_texturesolidmode->string); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); R_TexEnv(GL_REPLACE); if (qglPointParameterfEXT) { float attenuations[3]; attenuations[0] = gl_particle_att_a->value; attenuations[1] = gl_particle_att_b->value; attenuations[2] = gl_particle_att_c->value; /* GL_POINT_SMOOTH is not implemented by some OpenGL drivers, especially the crappy Mesa3D backends like i915.so. That the points are squares and not circles is not a problem by Quake II! */ qglEnable(GL_POINT_SMOOTH); qglPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, gl_particle_min_size->value); qglPointParameterfEXT(GL_POINT_SIZE_MAX_EXT, gl_particle_max_size->value); qglPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, attenuations); } if (qglColorTableEXT && gl_ext_palettedtexture->value) { qglEnable(GL_SHARED_TEXTURE_PALETTE_EXT); R_SetTexturePalette(d_8to24table); } }
//void RE_UploadCinematic( int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty ) { const void *RB_UploadCine( const void *data ) { const uploadCine_t *cmd; cmd = (const uploadCine_t *)data; int client = cmd->client; GL_Bind( tr.scratchImage[client] ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cmd->cols != tr.scratchImage[client]->width || cmd->rows != tr.scratchImage[client]->height ) { tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cmd->cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = cmd->rows; qglTexImage2D( GL_TEXTURE_2D, 0, 3, cmd->cols, cmd->rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, cmd->data ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); } else { if ( cmd->dirty ) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cmd->cols, cmd->rows, GL_RGBA, GL_UNSIGNED_BYTE, cmd->data ); } } return (const void *)( cmd + 1 ); }
/* =============== Draw_InitLocal =============== */ void Draw_InitLocal (void) { // load console characters (don't bilerp characters) draw_chars = GL_FindImage ("pics/conchars.pcx", it_pic); GL_Bind( draw_chars->texnum ); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); }
/* ** GL_SetDefaultState */ void GL_SetDefaultState( void ) { //qglClearColor (1,0, 0.5 , 0.5); // NeVo - f*****g ugly color! qglClearColor (0,0,0,1); // NeVo - clear to black qglCullFace(GL_FRONT); qglEnable(GL_TEXTURE_2D); qglEnable(GL_ALPHA_TEST); qglAlphaFunc(GL_GREATER, 0.666); qglDisable (GL_DEPTH_TEST); qglDisable (GL_CULL_FACE); qglDisable (GL_BLEND); qglColor4f (1,1,1,1); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglShadeModel (GL_FLAT); GL_TextureMode( gl_texturemode->string ); GL_TextureAlphaMode( gl_texturealphamode->string ); GL_TextureSolidMode( gl_texturesolidmode->string ); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); GL_TexEnv( GL_REPLACE ); if ( qglPointParameterfEXT ) { float attenuations[3]; attenuations[0] = gl_particle_att_a->value; attenuations[1] = gl_particle_att_b->value; attenuations[2] = gl_particle_att_c->value; qglEnable( GL_POINT_SMOOTH ); qglPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, gl_particle_min_size->value ); qglPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, gl_particle_max_size->value ); qglPointParameterfvEXT( GL_DISTANCE_ATTENUATION_EXT, attenuations ); } if ( qglColorTableEXT && gl_ext_palettedtexture->value ) { qglEnable( GL_SHARED_TEXTURE_PALETTE_EXT ); GL_SetTexturePalette( d_8to24table ); } GL_UpdateSwapInterval(); }
/* =============== GL_TextureMode =============== */ void GL_TextureMode( const char *string ) { size_t i; image_t *glt; for ( i = 0; i < numTextureModes ; i++ ) { if ( !Q_stricmp( modes[i].name, string ) ) { break; } } if ( i == numTextureModes ) { ri.Printf (PRINT_ALL, "bad filter name\n"); for ( i = 0; i < numTextureModes ; i++ ) { ri.Printf( PRINT_ALL, "%s\n", modes[i].name); } return; } gl_filter_min = modes[i].minimize; gl_filter_max = modes[i].maximize; // If the level they requested is less than possible, set the max possible... if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy ) { ri.Cvar_SetValue( "r_ext_texture_filter_anisotropic", glConfig.maxTextureFilterAnisotropy ); } // change all the existing mipmap texture objects // int iNumImages = R_Images_StartIteration(); while ( (glt = R_Images_GetNextIteration()) != NULL) { if ( glt->mipmap ) { GL_Bind (glt); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); if(glConfig.maxTextureFilterAnisotropy>0) { if(r_ext_texture_filter_anisotropic->integer>1) { qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value); } else { qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); } } } } }
void Draw_InitLocal(void) { /* load console characters (don't bilerp characters) */ draw_chars = Draw_FindPic("conchars"); if (!draw_chars) ri.Sys_Error(ERR_FATAL, "Couldn't load pics/conchars"); GL_Bind(draw_chars->texnum); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); if (font_color->string) { RefreshFont(); } }
void R_ScreenGamma(void) { if (gammaProgram.program) { glUseProgramObjectARB(gammaProgram.program); qglActiveTextureARB(GL_TEXTURE0_ARB); qglClientActiveTextureARB(GL_TEXTURE0_ARB); GL_Bind(screenImage); // We will copy the current buffer into the screenImage qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, glConfig.vidWidth, glConfig.vidHeight, 0); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glUniform1f(gammaProgram.gammaUniform, r_gamma->value); // Draw a simple quad, We could have done this in the GLSL code directly but that is version 130 upwards // and we want to be sure that R1 runs even with a toaster. glBegin(GL_QUADS); { glTexCoord2f(0.0, 0.0); glVertex3f(-1.0f, -1.0f, 0.0f); glTexCoord2f(1.0, 0.0); glVertex3f(1.0f, -1.0f, 0.0f); glTexCoord2f(1.0, 1.0); glVertex3f(1.0f, 1.0f, 0.0f); glTexCoord2f(0.0, 1.0); glVertex3f(-1.0f, 1.0f, 0.0f); } glEnd(); glUseProgramObjectARB(0); } }
void RE_UploadCinematic(int w, int h, int cols, int rows, const byte *data, int client, qbool dirty) { GL_Bind(tr.scratchImage[client]); /* if the scratchImage isn't in the format we want, specify it as a new texture */ if(cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height){ tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows; qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); }else{ if(dirty){ /* otherwise, just subimage upload it so that drivers can tell we are going to be changing * it and don't try and do a texture compression */ qglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data); } } }
void gld_SetTexFilters(GLTexture *gltexture) { int mip, mag_filter, min_filter; float aniso_filter = 0.0f; switch (gltexture->textype) { case GLDT_TEXTURE: case GLDT_FLAT: mip = MIP_TEXTURE; break; case GLDT_PATCH: mip = ((gltexture->flags & GLTEXTURE_SPRITE) ? MIP_SPRITE : MIP_PATCH); break; default: mip = MIP_TEXTURE; break; } if (render_usedetail && gltexture->detail) mag_filter = GL_LINEAR; else mag_filter = tex_filter[mip].mag_filter; if ((gltexture->flags & GLTEXTURE_MIPMAP) && tex_filter[mip].mipmap) { min_filter = tex_filter[mip].min_filter; if (gl_ext_texture_filter_anisotropic) aniso_filter = (GLfloat)(1<<gl_texture_filter_anisotropic); } else { min_filter = tex_filter[mip].mag_filter; } qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter); qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter); if (aniso_filter > 0.0f) qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso_filter); }
void CCamWnd::Cam_Draw() { brush_t *brush; face_t *face; float screenaspect; float yfov; double start, end; int i; /* FILE *f = fopen("g:/nardo/raduffy/editorhack.dat", "w"); if (f != NULL) { fwrite(&m_Camera.origin[0], sizeof(float), 1, f); fwrite(&m_Camera.origin[1], sizeof(float), 1, f); fwrite(&m_Camera.origin[2], sizeof(float), 1, f); fwrite(&m_Camera.angles[PITCH], sizeof(float), 1, f); fwrite(&m_Camera.angles[YAW], sizeof(float), 1, f); fclose(f); } */ if (!active_brushes.next) return; // not valid yet if (m_Camera.timing) start = Sys_DoubleTime (); // // clear // QE_CheckOpenGLForErrors(); qglViewport(0, 0, m_Camera.width, m_Camera.height); qglScissor(0, 0, m_Camera.width, m_Camera.height); qglClearColor (g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][0], g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][1], g_qeglobals.d_savedinfo.colors[COLOR_CAMERABACK][2], 0); qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // // set up viewpoint // vec5_t lightPos; if (g_PrefsDlg.m_bGLLighting) { qglEnable(GL_LIGHTING); //qglEnable(GL_LIGHT0); lightPos[0] = lightPos[1] = lightPos[2] = 3.5; lightPos[3] = 1.0; qglLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightPos); //qglLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); //lightPos[0] = lightPos[1] = lightPos[2] = 3.5; //qglLightfv(GL_LIGHT0, GL_AMBIENT, lightPos); } else { qglDisable(GL_LIGHTING); } qglMatrixMode(GL_PROJECTION); qglLoadIdentity (); screenaspect = (float)m_Camera.width / m_Camera.height; yfov = 2*atan((float)m_Camera.height / m_Camera.width)*180/Q_PI; qgluPerspective (yfov, screenaspect, 2, 8192); qglRotatef (-90, 1, 0, 0); // put Z going up qglRotatef (90, 0, 0, 1); // put Z going up qglRotatef (m_Camera.angles[0], 0, 1, 0); qglRotatef (-m_Camera.angles[1], 0, 0, 1); qglTranslatef (-m_Camera.origin[0], -m_Camera.origin[1], -m_Camera.origin[2]); Cam_BuildMatrix (); //if (m_Camera.draw_mode == cd_light) //{ // if (g_PrefsDlg.m_bGLLighting) // { // VectorCopy(m_Camera.origin, lightPos); // lightPos[3] = 1; // qglLightfv(GL_LIGHT0, GL_POSITION, lightPos); // } //} InitCull (); // // draw stuff // GLfloat lAmbient[] = {1.0, 1.0, 1.0, 1.0}; switch (m_Camera.draw_mode) { case cd_wire: qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE); qglDisable(GL_TEXTURE_2D); qglDisable(GL_TEXTURE_1D); qglDisable(GL_BLEND); qglDisable(GL_DEPTH_TEST); qglColor3f(1.0, 1.0, 1.0); // qglEnable (GL_LINE_SMOOTH); break; case cd_solid: qglCullFace(GL_FRONT); qglEnable(GL_CULL_FACE); qglShadeModel (GL_FLAT); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglDisable(GL_TEXTURE_2D); qglDisable(GL_BLEND); qglEnable(GL_DEPTH_TEST); qglDepthFunc (GL_LEQUAL); break; case cd_texture: qglCullFace(GL_FRONT); qglEnable(GL_CULL_FACE); qglShadeModel (GL_FLAT); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglEnable(GL_TEXTURE_2D); qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qglDisable(GL_BLEND); qglEnable(GL_DEPTH_TEST); qglDepthFunc (GL_LEQUAL); break; case cd_blend: qglCullFace(GL_FRONT); qglEnable(GL_CULL_FACE); qglShadeModel (GL_FLAT); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglEnable(GL_TEXTURE_2D); qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); qglDisable(GL_DEPTH_TEST); qglEnable (GL_BLEND); qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); break; } qglMatrixMode(GL_TEXTURE); m_nNumTransBrushes = 0; for (brush = active_brushes.next ; brush != &active_brushes ; brush=brush->next) { //DrawLightRadius(brush); if (CullBrush (brush)) continue; if (FilterBrush (brush)) continue; if ((brush->brush_faces->texdef.flags & (SURF_TRANS33 | SURF_TRANS66)) || (brush->brush_faces->d_texture->bFromShader && brush->brush_faces->d_texture->fTrans != 1.0)) { m_TransBrushes [ m_nNumTransBrushes++ ] = brush; } else { //-- if (brush->patchBrush) //-- m_TransBrushes [ m_nNumTransBrushes++ ] = brush; //-- else Brush_Draw(brush); } } if (g_PrefsDlg.m_bGLLighting) { qglDisable (GL_LIGHTING); } // //qglDepthMask ( 0 ); // Don't write to depth buffer qglEnable ( GL_BLEND ); qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); for ( i = 0; i < m_nNumTransBrushes; i++ ) Brush_Draw (m_TransBrushes[i]); //qglDepthMask ( 1 ); // Ok, write now qglMatrixMode(GL_PROJECTION); // // now draw selected brushes // if (g_PrefsDlg.m_bGLLighting) { qglEnable (GL_LIGHTING); } qglTranslatef (g_qeglobals.d_select_translate[0], g_qeglobals.d_select_translate[1], g_qeglobals.d_select_translate[2]); qglMatrixMode(GL_TEXTURE); brush_t* pList = (g_bClipMode && g_pSplitList) ? g_pSplitList : &selected_brushes; // draw normally for (brush = pList->next ; brush != pList ; brush=brush->next) { //DrawLightRadius(brush); //if (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) // continue; Brush_Draw(brush); } // blend on top qglMatrixMode(GL_PROJECTION); qglDisable (GL_LIGHTING); qglColor4f(1.0, 0.0, 0.0, 0.3); qglEnable (GL_BLEND); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); qglDisable (GL_TEXTURE_2D); for (brush = pList->next ; brush != pList ; brush=brush->next) { if ( (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) || (brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint) ) continue; for (face=brush->brush_faces ; face ; face=face->next) Face_Draw( face ); } int nCount = g_ptrSelectedFaces.GetSize(); if (nCount > 0) { for (int i = 0; i < nCount; i++) { face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(i)); Face_Draw(selFace); } } // non-zbuffered outline qglDisable (GL_BLEND); qglDisable (GL_DEPTH_TEST); qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE); qglColor3f (1, 1, 1); for (brush = pList->next ; brush != pList ; brush=brush->next) { if (g_qeglobals.dontDrawSelectedOutlines || (brush->patchBrush && g_qeglobals.d_select_mode == sel_curvepoint) || (brush->terrainBrush && g_qeglobals.d_select_mode == sel_terrainpoint)) continue; for (face=brush->brush_faces ; face ; face=face->next) Face_Draw( face ); } // edge / vertex flags if (g_qeglobals.d_select_mode == sel_vertex) { qglPointSize (4); qglColor3f (0,1,0); qglBegin (GL_POINTS); for (i=0 ; i<g_qeglobals.d_numpoints ; i++) qglVertex3fv (g_qeglobals.d_points[i]); qglEnd (); qglPointSize (1); } else if (g_qeglobals.d_select_mode == sel_edge) { float *v1, *v2; qglPointSize (4); qglColor3f (0,0,1); qglBegin (GL_POINTS); for (i=0 ; i<g_qeglobals.d_numedges ; i++) { v1 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p1]; v2 = g_qeglobals.d_points[g_qeglobals.d_edges[i].p2]; qglVertex3f ( (v1[0]+v2[0])*0.5,(v1[1]+v2[1])*0.5,(v1[2]+v2[2])*0.5); } qglEnd (); qglPointSize (1); } g_splineList->draw(static_cast<qboolean>(g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)); if (g_qeglobals.selectObject && (g_qeglobals.d_select_mode == sel_addpoint || g_qeglobals.d_select_mode == sel_editpoint)) { g_qeglobals.selectObject->drawSelection(); } // // draw pointfile // qglEnable(GL_DEPTH_TEST); DrawPathLines (); if (g_qeglobals.d_pointfile_display_list) { Pointfile_Draw(); // glCallList (g_qeglobals.d_pointfile_display_list); } // bind back to the default texture so that we don't have problems // elsewhere using/modifying texture maps between contexts qglBindTexture( GL_TEXTURE_2D, 0 ); #if 0 // area selection hack if (g_qeglobals.d_select_mode == sel_area) { qglEnable (GL_BLEND); qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); qglColor4f(0.0, 0.0, 1.0, 0.25); qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL); qglRectfv(g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR); qglDisable (GL_BLEND); } #endif qglFinish(); QE_CheckOpenGLForErrors(); // Sys_EndWait(); if (m_Camera.timing) { end = Sys_DoubleTime (); Sys_Printf ("Camera: %i ms\n", (int)(1000*(end-start))); } }
/* ============= RE_StretchRaw FIXME: not exactly backend Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle. Used for cinematics. ============= */ void RE_StretchRaw( int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty ) { int i, j; int start, end; if ( !tr.registered ) { return; } R_SyncRenderThread(); // we definitely want to sync every frame for the cinematics #if defined( USE_D3D10 ) // TODO #else qglFinish(); #endif start = end = 0; if ( r_speeds->integer ) { #if defined( USE_D3D10 ) // TODO #else qglFinish(); #endif start = ri.Milliseconds(); } // make sure rows and cols are powers of 2 for ( i = 0; ( 1 << i ) < cols; i++ ) { } for ( j = 0; ( 1 << j ) < rows; j++ ) { } if ( ( 1 << i ) != cols || ( 1 << j ) != rows ) { ri.Error( ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows ); } #if defined( USE_D3D10 ) // TODO #else RB_SetGL2D(); qglVertexAttrib4fARB( ATTR_INDEX_NORMAL, 0, 0, 1, 1 ); qglVertexAttrib4fARB( ATTR_INDEX_COLOR, tr.identityLight, tr.identityLight, tr.identityLight, 1 ); GL_BindProgram( &tr.genericSingleShader ); // set uniforms GLSL_SetUniform_TCGen_Environment( &tr.genericSingleShader, qfalse ); GLSL_SetUniform_ColorGen( &tr.genericSingleShader, CGEN_VERTEX ); GLSL_SetUniform_AlphaGen( &tr.genericSingleShader, AGEN_VERTEX ); //GLSL_SetUniform_Color(&tr.genericSingleShader, colorWhite); if ( glConfig.vboVertexSkinningAvailable ) { GLSL_SetUniform_VertexSkinning( &tr.genericSingleShader, qfalse ); } GLSL_SetUniform_DeformGen( &tr.genericSingleShader, DGEN_NONE ); GLSL_SetUniform_AlphaTest( &tr.genericSingleShader, 0 ); GLSL_SetUniform_ModelViewProjectionMatrix( &tr.genericSingleShader, glState.modelViewProjectionMatrix[ glState.stackIndex ] ); // bind u_ColorMap GL_SelectTexture( 0 ); GL_Bind( tr.scratchImage[ client ] ); GLSL_SetUniform_ColorTextureMatrix( &tr.genericSingleShader, matrixIdentity ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cols != tr.scratchImage[ client ]->width || rows != tr.scratchImage[ client ]->height ) { tr.scratchImage[ client ]->width = tr.scratchImage[ client ]->uploadWidth = cols; tr.scratchImage[ client ]->height = tr.scratchImage[ client ]->uploadHeight = rows; qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); } else { if ( dirty ) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data ); } } #endif // #if defined(USE_D3D10) if ( r_speeds->integer ) { #if defined( USE_D3D10 ) // TODO #else qglFinish(); #endif end = ri.Milliseconds(); ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start ); } tess.numVertexes = 0; tess.numIndexes = 0; tess.xyz[ tess.numVertexes ][ 0 ] = x; tess.xyz[ tess.numVertexes ][ 1 ] = y; tess.xyz[ tess.numVertexes ][ 2 ] = 0; tess.xyz[ tess.numVertexes ][ 3 ] = 1; tess.texCoords[ tess.numVertexes ][ 0 ] = 0.5f / cols; tess.texCoords[ tess.numVertexes ][ 1 ] = 0.5f / rows; tess.texCoords[ tess.numVertexes ][ 2 ] = 0; tess.texCoords[ tess.numVertexes ][ 3 ] = 1; tess.numVertexes++; tess.xyz[ tess.numVertexes ][ 0 ] = x + w; tess.xyz[ tess.numVertexes ][ 1 ] = y; tess.xyz[ tess.numVertexes ][ 2 ] = 0; tess.xyz[ tess.numVertexes ][ 3 ] = 1; tess.texCoords[ tess.numVertexes ][ 0 ] = ( cols - 0.5f ) / cols; tess.texCoords[ tess.numVertexes ][ 1 ] = 0.5f / rows; tess.texCoords[ tess.numVertexes ][ 2 ] = 0; tess.texCoords[ tess.numVertexes ][ 3 ] = 1; tess.numVertexes++; tess.xyz[ tess.numVertexes ][ 0 ] = x + w; tess.xyz[ tess.numVertexes ][ 1 ] = y + h; tess.xyz[ tess.numVertexes ][ 2 ] = 0; tess.xyz[ tess.numVertexes ][ 3 ] = 1; tess.texCoords[ tess.numVertexes ][ 0 ] = ( cols - 0.5f ) / cols; tess.texCoords[ tess.numVertexes ][ 1 ] = ( rows - 0.5f ) / rows; tess.texCoords[ tess.numVertexes ][ 2 ] = 0; tess.texCoords[ tess.numVertexes ][ 3 ] = 1; tess.numVertexes++; tess.xyz[ tess.numVertexes ][ 0 ] = x; tess.xyz[ tess.numVertexes ][ 1 ] = y + h; tess.xyz[ tess.numVertexes ][ 2 ] = 0; tess.xyz[ tess.numVertexes ][ 3 ] = 1; tess.texCoords[ tess.numVertexes ][ 0 ] = 0.5f / cols; tess.texCoords[ tess.numVertexes ][ 1 ] = ( rows - 0.5f ) / rows; tess.texCoords[ tess.numVertexes ][ 2 ] = 0; tess.texCoords[ tess.numVertexes ][ 3 ] = 1; tess.numVertexes++; tess.indexes[ tess.numIndexes++ ] = 0; tess.indexes[ tess.numIndexes++ ] = 1; tess.indexes[ tess.numIndexes++ ] = 2; tess.indexes[ tess.numIndexes++ ] = 0; tess.indexes[ tess.numIndexes++ ] = 2; tess.indexes[ tess.numIndexes++ ] = 3; Tess_UpdateVBOs( ATTR_POSITION | ATTR_TEXCOORD ); Tess_DrawElements(); tess.numVertexes = 0; tess.numIndexes = 0; #if defined( USE_D3D10 ) // TODO #else GL_CheckErrors(); #endif }
/* ======================== idImage::SetTexParameters ======================== */ void idImage::SetTexParameters() { int target = GL_TEXTURE_2D; switch ( opts.textureType ) { case TT_2D: target = GL_TEXTURE_2D; break; case TT_CUBIC: target = GL_TEXTURE_CUBE_MAP_EXT; break; default: idLib::FatalError( "%s: bad texture type %d", GetName(), opts.textureType ); return; } // ALPHA, LUMINANCE, LUMINANCE_ALPHA, and INTENSITY have been removed // in OpenGL 3.2. In order to mimic those modes, we use the swizzle operators #if defined( USE_CORE_PROFILE ) if ( opts.colorFormat == CFM_GREEN_ALPHA ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_GREEN ); } else if ( opts.format == FMT_LUM8 ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_ONE ); } else if ( opts.format == FMT_L8A8 ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_GREEN ); } else if ( opts.format == FMT_ALPHA ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_RED ); } else if ( opts.format == FMT_INT8 ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_RED ); } else { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_RED ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_GREEN ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_BLUE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_ALPHA ); } #else if ( opts.colorFormat == CFM_GREEN_ALPHA ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_GREEN ); } else if ( opts.format == FMT_ALPHA ) { qglTexParameteri( target, GL_TEXTURE_SWIZZLE_R, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_G, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_B, GL_ONE ); qglTexParameteri( target, GL_TEXTURE_SWIZZLE_A, GL_RED ); } #endif switch( filter ) { case TF_DEFAULT: if ( r_useTrilinearFiltering.GetBool() ) { qglTexParameterf( target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); } else { qglTexParameterf( target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST ); } qglTexParameterf( target, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); break; case TF_LINEAR: qglTexParameterf( target, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( target, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); break; case TF_NEAREST: qglTexParameterf( target, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); qglTexParameterf( target, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); break; default: common->FatalError( "%s: bad texture filter %d", GetName(), filter ); } if ( glConfig.anisotropicFilterAvailable ) { // only do aniso filtering on mip mapped images if ( filter == TF_DEFAULT ) { int aniso = r_maxAnisotropicFiltering.GetInteger(); if ( aniso > glConfig.maxTextureAnisotropy ) { aniso = glConfig.maxTextureAnisotropy; } if ( aniso < 0 ) { aniso = 0; } qglTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso ); } else { qglTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1 ); } } if ( glConfig.textureLODBiasAvailable && ( usage != TD_FONT ) ) { // use a blurring LOD bias in combination with high anisotropy to fix our aliasing grate textures... qglTexParameterf(target, GL_TEXTURE_LOD_BIAS_EXT, r_lodBias.GetFloat() ); } // set the wrap/clamp modes switch( repeat ) { case TR_REPEAT: qglTexParameterf( target, GL_TEXTURE_WRAP_S, GL_REPEAT ); qglTexParameterf( target, GL_TEXTURE_WRAP_T, GL_REPEAT ); break; case TR_CLAMP_TO_ZERO: { float color[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; qglTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, color ); qglTexParameterf( target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER ); qglTexParameterf( target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER ); } break; case TR_CLAMP_TO_ZERO_ALPHA: { float color[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; qglTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, color ); qglTexParameterf( target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER ); qglTexParameterf( target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER ); } break; case TR_CLAMP: qglTexParameterf( target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); qglTexParameterf( target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); break; default: common->FatalError( "%s: bad texture repeat %d", GetName(), repeat ); } }
/* * RE_StretchRaw * * FIXME: not exactly backend * Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle. * Used for cinematics. */ void RE_StretchRaw(int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qbool dirty) { int i, j; int start, end; shaderProgram_t *sp = &tr.textureColorShader; Vec4 color; if(!tr.registered){ return; } R_SyncRenderThread(); /* we definately want to sync every frame for the cinematics */ qglFinish(); start = 0; if(r_speeds->integer){ start = ri.Milliseconds(); } /* make sure rows and cols are powers of 2 */ for(i = 0; (1 << i) < cols; i++){ } for(j = 0; (1 << j) < rows; j++){ } if((1 << i) != cols || (1 << j) != rows){ ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows); } GL_Bind(tr.scratchImage[client]); /* if the scratchImage isn't in the format we want, specify it as a new texture */ if(cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height){ tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows; qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); }else{ if(dirty){ /* otherwise, just subimage upload it so that drivers can tell we are going to be changing * it and don't try and do a texture compression */ qglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data); } } if(r_speeds->integer){ end = ri.Milliseconds(); ri.Printf(PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start); } /* FIXME: HUGE hack */ if(glRefConfig.framebufferObject && !glState.currentFBO){ if(backEnd.framePostProcessed){ FBO_Bind(tr.screenScratchFbo); }else{ FBO_Bind(tr.renderFbo); } } RB_SetGL2D(); tess.numIndexes = 0; tess.numVertexes = 0; tess.firstIndex = 0; tess.xyz[tess.numVertexes][0] = x; tess.xyz[tess.numVertexes][1] = y; tess.xyz[tess.numVertexes][2] = 0; tess.xyz[tess.numVertexes][3] = 1; tess.texCoords[tess.numVertexes][0][0] = 0.5f / cols; tess.texCoords[tess.numVertexes][0][1] = 0.5f / rows; tess.texCoords[tess.numVertexes][0][2] = 0; tess.texCoords[tess.numVertexes][0][3] = 1; tess.numVertexes++; tess.xyz[tess.numVertexes][0] = x + w; tess.xyz[tess.numVertexes][1] = y; tess.xyz[tess.numVertexes][2] = 0; tess.xyz[tess.numVertexes][3] = 1; tess.texCoords[tess.numVertexes][0][0] = (cols - 0.5f) / cols; tess.texCoords[tess.numVertexes][0][1] = 0.5f / rows; tess.texCoords[tess.numVertexes][0][2] = 0; tess.texCoords[tess.numVertexes][0][3] = 1; tess.numVertexes++; tess.xyz[tess.numVertexes][0] = x + w; tess.xyz[tess.numVertexes][1] = y + h; tess.xyz[tess.numVertexes][2] = 0; tess.xyz[tess.numVertexes][3] = 1; tess.texCoords[tess.numVertexes][0][0] = (cols - 0.5f) / cols; tess.texCoords[tess.numVertexes][0][1] = (rows - 0.5f) / rows; tess.texCoords[tess.numVertexes][0][2] = 0; tess.texCoords[tess.numVertexes][0][3] = 1; tess.numVertexes++; tess.xyz[tess.numVertexes][0] = x; tess.xyz[tess.numVertexes][1] = y + h; tess.xyz[tess.numVertexes][2] = 0; tess.xyz[tess.numVertexes][3] = 1; tess.texCoords[tess.numVertexes][0][0] = 0.5f / cols; tess.texCoords[tess.numVertexes][0][1] = (rows - 0.5f) / rows; tess.texCoords[tess.numVertexes][0][2] = 0; tess.texCoords[tess.numVertexes][0][3] = 1; tess.numVertexes++; tess.indexes[tess.numIndexes++] = 0; tess.indexes[tess.numIndexes++] = 1; tess.indexes[tess.numIndexes++] = 2; tess.indexes[tess.numIndexes++] = 0; tess.indexes[tess.numIndexes++] = 2; tess.indexes[tess.numIndexes++] = 3; /* FIXME: A lot of this can probably be removed for speed, and refactored into a more convenient function */ RB_UpdateVBOs(ATTR_POSITION | ATTR_TEXCOORD); sp = &tr.textureColorShader; GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD); GLSL_BindProgram(sp); GLSL_SetUniformMatrix16(sp, TEXTURECOLOR_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection); setv34(color, 1, 1, 1, 1); GLSL_SetUniformVec4(sp, TEXTURECOLOR_UNIFORM_COLOR, color); qglDrawElements(GL_TRIANGLES, tess.numIndexes, GL_INDEX_TYPE, BUFFER_OFFSET(0)); /* R_BindNullVBO(); * R_BindNullIBO(); */ tess.numIndexes = 0; tess.numVertexes = 0; tess.firstIndex = 0; }
GLvoid APIENTRY GLDSA_TextureParameterf(GLuint texture, GLenum target, GLenum pname, GLfloat param) { GL_BindMultiTexture(glDsaState.texunit, target, texture); qglTexParameterf(target, pname, param); }
/* ============= RE_StretchRaw FIXME: not exactly backend Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle. Used for cinematics. ============= */ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) { int i, j; int start, end; #ifdef VCMODS_OPENGLES vec2_t texcoords[4]; vec2_t verts[4]; glIndex_t indicies[6] = {0, 1, 2, 0, 3, 2}; #endif if ( !tr.registered ) { return; } R_SyncRenderThread(); // we definately want to sync every frame for the cinematics qglFinish(); start = end = 0; if ( r_speeds->integer ) { start = ri.Milliseconds(); } // make sure rows and cols are powers of 2 for ( i = 0 ; ( 1 << i ) < cols ; i++ ) { } for ( j = 0 ; ( 1 << j ) < rows ; j++ ) { } if ( ( 1 << i ) != cols || ( 1 << j ) != rows) { ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows); } GL_Bind( tr.scratchImage[client] ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) { tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows; #ifdef VCMODS_OPENGLES //don't do qglTexImage2D as this may end up doing a compressed image //on which we are not allowed to do further sub images glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); #else qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); #endif qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); } else { if (dirty) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data ); } } if ( r_speeds->integer ) { end = ri.Milliseconds(); ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start ); } RB_SetGL2D(); #ifdef VCMODS_OPENGLES qglColor4f( tr.identityLight, tr.identityLight, tr.identityLight, 1.0f ); verts[0][0] = x; verts[0][1] = y; verts[1][0] = x+w; verts[1][1] = y; verts[2][0] = x+w; verts[2][1] = y+h; verts[3][0] = x; verts[3][1] = y+h; texcoords[0][0] = 0.5f/cols; texcoords[0][1] = 0.5f/rows; texcoords[1][0] = (cols-0.5f)/cols; texcoords[1][1] = 0.5f/rows; texcoords[2][0] = (cols-0.5f)/cols; texcoords[2][1] = (rows-0.5f)/rows; texcoords[3][0] = 0.5f/cols; texcoords[3][1] = (rows-0.5f)/rows; qglEnableClientState( GL_TEXTURE_COORD_ARRAY ); qglTexCoordPointer( 2, GL_FLOAT, 0, texcoords ); qglVertexPointer ( 2, GL_FLOAT, 0, verts ); qglDrawElements( GL_TRIANGLE_STRIP, 6, GL_INDEX_TYPE, indicies ); qglDisableClientState( GL_TEXTURE_COORD_ARRAY ); #else qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight ); qglBegin (GL_QUADS); qglTexCoord2f ( 0.5f / cols, 0.5f / rows ); qglVertex2f (x, y); qglTexCoord2f ( ( cols - 0.5f ) / cols , 0.5f / rows ); qglVertex2f (x+w, y); qglTexCoord2f ( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows ); qglVertex2f (x+w, y+h); qglTexCoord2f ( 0.5f / cols, ( rows - 0.5f ) / rows ); qglVertex2f (x, y+h); qglEnd (); #endif }
/* ============= RE_StretchRaw FIXME: not exactly backend Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle. Used for cinematics. ============= */ void RE_StretchRaw( int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty ) { int i, j; int start, end; if ( !tr.registered ) { return; } R_IssuePendingRenderCommands(); if ( tess.numIndexes ) { RB_EndSurface(); } // we definately want to sync every frame for the cinematics qglFinish(); start = 0; if ( r_speeds->integer ) { start = ri.Milliseconds(); } // make sure rows and cols are powers of 2 for ( i = 0 ; ( 1 << i ) < cols ; i++ ) { } for ( j = 0 ; ( 1 << j ) < rows ; j++ ) { } if ( ( 1 << i ) != cols || ( 1 << j ) != rows ) { ri.Error( ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows ); } GL_Bind( tr.scratchImage[client] ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) { tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows; #ifdef USE_OPENGLES qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); #else qglTexImage2D( GL_TEXTURE_2D, 0, 3, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); #endif qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); } else { if ( dirty ) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data ); } } if ( r_speeds->integer ) { end = ri.Milliseconds(); ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start ); } RB_SetGL2D(); qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight ); #ifdef USE_OPENGLES GLfloat tex[] = { 0.5f / cols, 0.5f / rows, ( cols - 0.5f ) / cols , 0.5f / rows, ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows, 0.5f / cols, ( rows - 0.5f ) / rows }; GLfloat vtx[] = { x, y, x+w, y, x+w, y+h, x, y+h }; GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY); GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY); if (glcol) qglDisableClientState(GL_COLOR_ARRAY); if (!text) qglEnableClientState( GL_TEXTURE_COORD_ARRAY ); qglTexCoordPointer( 2, GL_FLOAT, 0, tex ); qglVertexPointer ( 2, GL_FLOAT, 0, vtx ); qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 ); if (!text) qglDisableClientState( GL_TEXTURE_COORD_ARRAY ); if (glcol) qglEnableClientState(GL_COLOR_ARRAY); #else qglBegin( GL_QUADS ); qglTexCoord2f( 0.5f / cols, 0.5f / rows ); qglVertex2f( x, y ); qglTexCoord2f( ( cols - 0.5f ) / cols, 0.5f / rows ); qglVertex2f( x + w, y ); qglTexCoord2f( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows ); qglVertex2f( x + w, y + h ); qglTexCoord2f( 0.5f / cols, ( rows - 0.5f ) / rows ); qglVertex2f( x, y + h ); qglEnd(); #endif }
/********* SP_DrawTexture *********/ void SP_DrawTexture(void* pixels, float width, float height, float vShift) { if (!pixels) { // Ug. We were not even able to load the error message texture. return; } // Create a texture from the buffered file GLuint texid; qglGenTextures(1, &texid); qglBindTexture(GL_TEXTURE_2D, texid); qglTexImage2D(GL_TEXTURE_2D, 0, GL_DDS1_EXT, width, height, 0, GL_DDS1_EXT, GL_UNSIGNED_BYTE, pixels); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); // Reset every GL state we've got. Who knows what state // the renderer could be in when this function gets called. qglColor3f(1.f, 1.f, 1.f); qglViewport(0, 0, 640, 480); GLboolean alpha = qglIsEnabled(GL_ALPHA_TEST); qglDisable(GL_ALPHA_TEST); GLboolean blend = qglIsEnabled(GL_BLEND); qglDisable(GL_BLEND); GLboolean cull = qglIsEnabled(GL_CULL_FACE); qglDisable(GL_CULL_FACE); GLboolean depth = qglIsEnabled(GL_DEPTH_TEST); qglDisable(GL_DEPTH_TEST); GLboolean fog = qglIsEnabled(GL_FOG); qglDisable(GL_FOG); GLboolean lighting = qglIsEnabled(GL_LIGHTING); qglDisable(GL_LIGHTING); GLboolean offset = qglIsEnabled(GL_POLYGON_OFFSET_FILL); qglDisable(GL_POLYGON_OFFSET_FILL); GLboolean scissor = qglIsEnabled(GL_SCISSOR_TEST); qglDisable(GL_SCISSOR_TEST); GLboolean stencil = qglIsEnabled(GL_STENCIL_TEST); qglDisable(GL_STENCIL_TEST); GLboolean texture = qglIsEnabled(GL_TEXTURE_2D); qglEnable(GL_TEXTURE_2D); qglMatrixMode(GL_MODELVIEW); qglLoadIdentity(); qglMatrixMode(GL_PROJECTION); qglLoadIdentity(); qglOrtho(0, 640, 0, 480, 0, 1); qglMatrixMode(GL_TEXTURE0); qglLoadIdentity(); qglMatrixMode(GL_TEXTURE1); qglLoadIdentity(); qglActiveTextureARB(GL_TEXTURE0_ARB); qglClientActiveTextureARB(GL_TEXTURE0_ARB); memset(&tess, 0, sizeof(tess)); // Draw the error message qglBeginFrame(); if (!SP_LicenseDone) { // clear the screen if we haven't done the // license yet... qglClearColor(0, 0, 0, 1); qglClear(GL_COLOR_BUFFER_BIT); } float x1 = 320 - width / 2; float x2 = 320 + width / 2; float y1 = 240 - height / 2; float y2 = 240 + height / 2; y1 += vShift; y2 += vShift; qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0); qglTexCoord2f( 0, 0 ); qglVertex2f(x1, y1); qglTexCoord2f( 1 , 0 ); qglVertex2f(x2, y1); qglTexCoord2f( 0, 1 ); qglVertex2f(x1, y2); qglTexCoord2f( 1, 1 ); qglVertex2f(x2, y2); qglEnd(); qglEndFrame(); qglFlush(); // Restore (most) of the render states we reset if (alpha) qglEnable(GL_ALPHA_TEST); else qglDisable(GL_ALPHA_TEST); if (blend) qglEnable(GL_BLEND); else qglDisable(GL_BLEND); if (cull) qglEnable(GL_CULL_FACE); else qglDisable(GL_CULL_FACE); if (depth) qglEnable(GL_DEPTH_TEST); else qglDisable(GL_DEPTH_TEST); if (fog) qglEnable(GL_FOG); else qglDisable(GL_FOG); if (lighting) qglEnable(GL_LIGHTING); else qglDisable(GL_LIGHTING); if (offset) qglEnable(GL_POLYGON_OFFSET_FILL); else qglDisable(GL_POLYGON_OFFSET_FILL); if (scissor) qglEnable(GL_SCISSOR_TEST); else qglDisable(GL_SCISSOR_TEST); if (stencil) qglEnable(GL_STENCIL_TEST); else qglDisable(GL_STENCIL_TEST); if (texture) qglEnable(GL_TEXTURE_2D); else qglDisable(GL_TEXTURE_2D); // Kill the texture qglDeleteTextures(1, &texid); }
/* ============= RE_StretchRaw FIXME: not exactly backend Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle. Used for cinematics. ============= */ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) { int i, j; int start, end; if ( !tr.registered ) { return; } R_SyncRenderThread(); // we definately want to sync every frame for the cinematics qglFinish(); start = end = 0; if ( r_speeds->integer ) { start = ri.Milliseconds(); } // make sure rows and cols are powers of 2 for ( i = 0 ; ( 1 << i ) < cols ; i++ ) { } for ( j = 0 ; ( 1 << j ) < rows ; j++ ) { } if ( ( 1 << i ) != cols || ( 1 << j ) != rows) { ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows); } GL_Bind( tr.scratchImage[client] ); // if the scratchImage isn't in the format we want, specify it as a new texture if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) { tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols; tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows; qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); } else { if (dirty) { // otherwise, just subimage upload it so that drivers can tell we are going to be changing // it and don't try and do a texture compression qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data ); } } if ( r_speeds->integer ) { end = ri.Milliseconds(); ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start ); } RB_SetGL2D(); qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight ); qglBegin (GL_QUADS); qglTexCoord2f ( 0.5f / cols, 0.5f / rows ); qglVertex2f (x, y); qglTexCoord2f ( ( cols - 0.5f ) / cols , 0.5f / rows ); qglVertex2f (x+w, y); qglTexCoord2f ( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows ); qglVertex2f (x+w, y+h); qglTexCoord2f ( 0.5f / cols, ( rows - 0.5f ) / rows ); qglVertex2f (x, y+h); qglEnd (); }
CRainSystem::CRainSystem(int maxRain) : mMaxRain(maxRain), mNextWindGust(0), mRainHeight(5), mAlpha(0.15f), mWindAngle(1.0f), mFadeAlpha(0.0f), mIsRaining(false) { char name[256]; unsigned char *data, *pos; int width, height; int x, y; mSpread[0] = (float)(M_PI*2.0); // angle spread mSpread[1] = 20.0f; // radius spread mSpread[2] = 20.0f; // z spread mMinVelocity[0] = 0.1f; mMaxVelocity[0] = -0.1f; mMinVelocity[1] = 0.1f; mMaxVelocity[1] = -0.1f; mMinVelocity[2] = -60.0; mMaxVelocity[2] = -50.0; mWindDuration = 15; mWindLow = 50; mWindMin = 0.01f; mWindMax = 0.05f; mWindChange = 0; mWindDirection[0] = mWindDirection[1] = mWindDirection[2] = 0.0; mRainList = new SParticle[mMaxRain]; sprintf(name, "gfx/world/rain.tga"); R_LoadImage( name, &data, &width, &height ); if (!data) { ri.Error (ERR_DROP, "Could not load %s", name); } pos = data; for(y=0;y<height;y++) { for(x=0;x<width;x++) { pos[3] = pos[0]; pos += 4; } } mImage = R_CreateImage(name, data, width, height, false, false, false, GL_CLAMP); GL_Bind(mImage); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); Init(); }