mittorn/Paranoia2
1
0
Fork 0
forked from FWGS/Paranoia2
Code Issues Pull Requests Projects Releases Wiki Activity
0455f5d6e2
Paranoia2/utils/hlmv/GlWindow.cpp

799 lines
22 KiB
C++
Raw Blame History

//
// Half-Life Model Viewer (c) 1999 by Mete Ciragan
//
// file: GlWindow.cpp
// last modified: May 04 1999, Mete Ciragan
// copyright: The programs and associated files contained in this
// distribution were developed by Mete Ciragan. The programs
// are not in the public domain, but they are freely
// distributable without licensing fees. These programs are
// provided without guarantee or warrantee expressed or
// implied.
//
// version: 1.2
//
// email: mete@swissquake.ch
// web: http://www.swissquake.ch/chumbalum-soft/
//
#include <mx.h>
#include <mxMessageBox.h>
#include <mxTga.h>
#include <mxPcx.h>
#include <mxBmp.h>
#include <gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "GlWindow.h"
#include "StudioModel.h"
#include "ViewerSettings.h"
#include "ControlPanel.h"
#include "stringlib.h"
#include "mdlviewer.h"
#include "muzzle1.h"
#include "muzzle2.h"
#include "muzzle3.h"
extern char g_appTitle[];
extern bool g_bStopPlaying;
extern bool bUseWeaponOrigin;
extern bool bUseWeaponLeftHand;
extern bool bUseParanoiaFOV;
GlWindow *g_GlWindow = 0;
GlWindow :: GlWindow( mxWindow *parent, int x, int y, int w, int h, const char *label, int style ) : mxGlWindow( parent, x, y, w, h, label, style )
{
glDepthFunc( GL_LEQUAL );
if( !parent ) setVisible( true );
else mx :: setIdleWindow ( this );
// load muzzle flahses
loadTextureBuffer( muzzleflash1_bmp, sizeof( muzzleflash1_bmp ), TEXTURE_MUZZLEFLASH1 );
loadTextureBuffer( muzzleflash2_bmp, sizeof( muzzleflash2_bmp ), TEXTURE_MUZZLEFLASH2 );
loadTextureBuffer( muzzleflash3_bmp, sizeof( muzzleflash3_bmp ), TEXTURE_MUZZLEFLASH3 );
}
GlWindow :: ~GlWindow( void )
{
mx::setIdleWindow( 0 );
loadTexture( NULL, TEXTURE_GROUND );
loadTexture( NULL, TEXTURE_BACKGROUND );
loadTexture( NULL, TEXTURE_MUZZLEFLASH1 );
loadTexture( NULL, TEXTURE_MUZZLEFLASH2 );
loadTexture( NULL, TEXTURE_MUZZLEFLASH3 );
}
int GlWindow :: handleEvent( mxEvent *event )
{
static float oldrx, oldry, oldtz, oldtx, oldty;
static float oldlx, oldly;
static int oldx, oldy;
static double lastupdate;
switch( event->event )
{
case mxEvent::Idle:
{
static double prev;
double curr = (double) mx::getTickCount () / 1000.0;
double dt = (curr - prev);
#if 1
// clamp to 100fps
if( dt >= 0.0 && dt < 0.01 )
{
Sleep( Q_max( 10 - dt * 1000.0, 0 ) );
return 1;
}
#endif
g_studioModel.updateTimings( curr, dt );
rand (); // keep the random time dependent
if( !g_bStopPlaying && !g_viewerSettings.pause && prev != 0.0 )
{
if( !g_studioModel.AdvanceFrame( dt * g_viewerSettings.speedScale ))
d_cpl->resetPlayingSequence(); // hit the end of sequence
}
if( !g_viewerSettings.pause )
redraw();
// update counter every 0.2 secs
if(( curr - lastupdate ) > 0.2 )
{
g_ControlPanel->updateDrawnPolys();
lastupdate = curr;
}
prev = curr;
return 1;
}
break;
case mxEvent::MouseUp:
{
g_viewerSettings.pause = false;
}
break;
case mxEvent::MouseDown:
{
oldrx = g_viewerSettings.rot[0];
oldry = g_viewerSettings.rot[1];
oldtx = g_viewerSettings.trans[0];
oldty = g_viewerSettings.trans[1];
oldtz = g_viewerSettings.trans[2];
oldlx = g_viewerSettings.gLightVec[0];
oldly = g_viewerSettings.gLightVec[1];
oldx = event->x;
oldy = event->y;
// HACKHACK: reset focus to main window to catch hot-keys again
if( g_MDLViewer ) SetFocus( (HWND) g_MDLViewer->getHandle ());
g_viewerSettings.pause = true;
return 1;
}
break;
case mxEvent::MouseDrag:
{
if( g_viewerSettings.showTexture )
{
redraw ();
return 1;
}
if( event->buttons & mxEvent::MouseLeftButton )
{
if( event->modifiers & mxEvent::KeyShift )
{
g_viewerSettings.trans[0] = oldtx - (float)(event->x - oldx) * g_viewerSettings.movementScale;
g_viewerSettings.trans[1] = oldty + (float)(event->y - oldy) * g_viewerSettings.movementScale;
}
else if( event->modifiers & mxEvent::KeyCtrl )
{
float yaw = oldlx + (float)(event->x - oldx);
float pitch = oldly + (float)(event->y - oldy);
float sy, cy, sp, cp;
pitch = DEG2RAD( anglemod( pitch * 0.6f ));
yaw = DEG2RAD( anglemod( yaw * 0.6f ));
SinCos( yaw, &sy, &cy );
SinCos( pitch, &sp, &cp );
g_viewerSettings.gLightVec[0] = (cp*cy);
g_viewerSettings.gLightVec[1] = (-sy);
g_viewerSettings.gLightVec[2] = (sp*cy);
}
else
{
g_viewerSettings.rot[0] = oldrx + (float)(event->y - oldy);
g_viewerSettings.rot[1] = oldry + (float)(event->x - oldx);
}
}
else if( event->buttons & mxEvent::MouseRightButton )
{
g_viewerSettings.trans[2] = oldtz + (float)(event->y - oldy) * g_viewerSettings.movementScale;
}
redraw ();
return 1;
}
break;
} // switch (event->event)
return 1;
}
void GlWindow :: drawFloor( int texture )
{
float scale = 5.0f;
float dist = -100.0f;
glEnable( GL_MULTISAMPLE );
if( texture )
{
static Vector tMap( 0, 0, 0 );
static Vector dxMap( 1, 0, 0 );
static Vector dyMap( 0, 1, 0 );
Vector deltaPos;
Vector deltaAngles;
g_studioModel.GetMovement( g_studioModel.m_prevGroundCycle, deltaPos, deltaAngles );
float dpdd = scale / dist;
tMap.x = tMap.x + dxMap.x * deltaPos.x * dpdd + dxMap.y * deltaPos.y * dpdd;
tMap.y = tMap.y + dyMap.x * deltaPos.x * dpdd + dyMap.y * deltaPos.y * dpdd;
while (tMap.x < 0.0) tMap.x += 1.0f;
while (tMap.x > 1.0) tMap.x += -1.0f;
while (tMap.y < 0.0) tMap.y += 1.0f;
while (tMap.y > 1.0) tMap.y += -1.0f;
dxMap = VectorYawRotate( dxMap, -deltaAngles.y );
dyMap = VectorYawRotate( dyMap, -deltaAngles.y );
glBegin( GL_QUADS );
glTexCoord2f( tMap.x - (dxMap.x - dyMap.x) * scale, tMap.y - (-dxMap.y + dyMap.y) * scale );
glVertex3f( -dist, -dist, 0 );
glTexCoord2f( tMap.x + (dxMap.x + dyMap.x) * scale, tMap.y + (-dxMap.y - dyMap.y) * scale );
glVertex3f( dist, -dist, 0 );
glTexCoord2f( tMap.x + (dxMap.x - dyMap.x) * scale, tMap.y + (-dxMap.y + dyMap.y) * scale );
glVertex3f( dist, dist, 0 );
glTexCoord2f( tMap.x + (-dxMap.x - dyMap.x) * scale, tMap.y + (dxMap.y + dyMap.y) * scale );
glVertex3f( -dist, dist, 0 );
glEnd();
}
else
{
glBegin( GL_QUADS );
glTexCoord2f( 0.0f, 1.0f );
glVertex3f( -dist, -dist, 0 );
glTexCoord2f( 1.0f, 1.0f );
glVertex3f( dist, -dist, 0 );
glTexCoord2f( 1.0f, 0.0f );
glVertex3f( dist, dist, 0 );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( -dist, dist, 0 );
glEnd();
}
// restore original modelview
SetModelviewMatrix( m_modelview );
glDisable( GL_MULTISAMPLE );
}
void GlWindow :: setupRenderMode( void )
{
switch( g_viewerSettings.renderMode )
{
case RM_WIREFRAME:
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glDisable( GL_TEXTURE_2D );
glDisable( GL_CULL_FACE );
glEnable( GL_DEPTH_TEST );
break;
case RM_FLATSHADED:
case RM_SMOOTHSHADED:
case RM_BONEWEIGHTS:
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glDisable( GL_TEXTURE_2D );
glEnable( GL_CULL_FACE );
glEnable( GL_DEPTH_TEST );
if( g_viewerSettings.renderMode == RM_FLATSHADED )
glShadeModel( GL_FLAT );
else glShadeModel( GL_SMOOTH );
break;
default:
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glEnable( GL_TEXTURE_2D );
glEnable( GL_CULL_FACE );
glEnable( GL_DEPTH_TEST );
glShadeModel( GL_SMOOTH );
break;
}
}
void GlWindow :: GluPerspective( float fov_y )
{
GLdouble xMin, xMax, yMin, yMax, zNear, zFar;
float aspect = (float)w() / h();
zFar = 131072.0f; // don't cull giantic models (e.g. skybox models)
zNear = bUseWeaponOrigin ? 4.0f : 0.1f; // ammo shell issues
if( bUseWeaponOrigin && bUseParanoiaFOV )
{
float fovX = 60.0f; // HL2 uses 54 as default
float fovY = V_CalcFov( fovX, w(), h() );
yMax = zNear * tan( fovY * M_PI / 360.0 );
yMin = -yMax;
xMax = zNear * tan( fovX * M_PI / 360.0 );
xMin = -xMax;
}
else
{
yMax = zNear * tan( fov_y * M_PI / 360.0 );
yMin = -yMax;
xMin = yMin * aspect;
xMax = yMax * aspect;
}
m_projection.CreateProjection( xMax, xMin, yMax, yMin, zNear, zFar );
SetProjectionMatrix( m_projection );
}
void GlWindow :: SetProjectionMatrix( const matrix4x4 source )
{
GLfloat dest[16];
source.CopyToArray( dest );
glMatrixMode( GL_PROJECTION );
glLoadMatrixf( dest );
}
void GlWindow :: SetModelviewMatrix( const matrix4x4 source )
{
GLfloat dest[16];
source.CopyToArray( dest );
glMatrixMode( GL_MODELVIEW );
glLoadMatrixf( dest );
}
void GlWindow :: ResetModelviewMatrix( void )
{
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
void GlWindow :: draw( void )
{
glClearColor( g_viewerSettings.bgColor[0], g_viewerSettings.bgColor[1], g_viewerSettings.bgColor[2], 0.0f );
if( g_viewerSettings.useStencil )
glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
else glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
glViewport( 0, 0, w2(), h2() );
glDisable( GL_MULTISAMPLE );
// remap textures if changed
g_studioModel.RemapTextures();
//
// show textures
//
if( g_viewerSettings.showTexture )
{
m_projection.CreateOrtho( 0.0f, w2(), h2(), 0.0f, 1.0f, -1.0f );
SetProjectionMatrix( m_projection );
glDisable( GL_MULTISAMPLE );
studiohdr_t *hdr = g_studioModel.getTextureHeader();
if( hdr )
{
mstudiotexture_t *ptextures = (mstudiotexture_t *)((byte *)hdr + hdr->textureindex);
float w = (float) ptextures[g_viewerSettings.texture].width * g_viewerSettings.textureScale;
float h = (float) ptextures[g_viewerSettings.texture].height * g_viewerSettings.textureScale;
ResetModelviewMatrix();
glDisable( GL_CULL_FACE );
glDisable( GL_BLEND );
if( ptextures[g_viewerSettings.texture].flags & STUDIO_NF_MASKED )
{
glEnable( GL_ALPHA_TEST );
glAlphaFunc( GL_GREATER, 0.25f );
}
else glDisable( GL_ALPHA_TEST );
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
float x = ((float)w2 () - w) / 2;
float y = ((float)h2 () - h) / 2;
if(( g_viewerSettings.show_uv_map || g_viewerSettings.pending_export_uvmap ) && !g_viewerSettings.overlay_uv_map )
{
glColor4f (0.0f, 0.0f, 0.0f, 1.0f);
glDisable (GL_TEXTURE_2D);
}
else
{
glEnable (GL_TEXTURE_2D);
glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
glBindTexture (GL_TEXTURE_2D, TEXTURE_COUNT + g_viewerSettings.texture );
}
glBegin( GL_TRIANGLE_STRIP );
glTexCoord2f( 0, 0 );
glVertex2f( x, y );
glTexCoord2f( 1, 0 );
glVertex2f( x + w, y );
glTexCoord2f( 0, 1 );
glVertex2f( x, y + h );
glTexCoord2f( 1, 1 );
glVertex2f( x + w, y + h );
glEnd();
if( g_viewerSettings.show_uv_map || g_viewerSettings.pending_export_uvmap || g_viewerSettings.overlay_uv_map )
{
if( g_viewerSettings.anti_alias_lines )
{
glEnable( GL_LINE_SMOOTH );
glEnable( GL_POLYGON_SMOOTH );
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
g_studioModel.SetOffset2D( x, y );
g_studioModel.DrawModelUVMap();
if( g_viewerSettings.anti_alias_lines )
{
glDisable( GL_LINE_SMOOTH );
glDisable(GL_POLYGON_SMOOTH);
}
}
if( g_viewerSettings.pending_export_uvmap && g_viewerSettings.uvmapPath[0] )
{
mxImage *image = new mxImage ();
if( image->create((int)w, (int)h, 24 ))
{
glReadBuffer( GL_BACK );
glReadPixels((int)x-1, (int)y, (int)w, (int)h, GL_RGB, GL_UNSIGNED_BYTE, image->data );
image->flip_vertical();
if( !mxBmpWrite( g_viewerSettings.uvmapPath, image ))
mxMessageBox( this, "Error writing .BMP texture.", g_appTitle, MX_MB_OK|MX_MB_ERROR );
}
// cleanup
memset( g_viewerSettings.uvmapPath, 0, sizeof( g_viewerSettings.uvmapPath ));
g_viewerSettings.pending_export_uvmap = false;
delete image;
}
glClear( GL_DEPTH_BUFFER_BIT );
glBindTexture( GL_TEXTURE_2D, 0 );
}
return;
}
//
// draw background
//
if( g_viewerSettings.showBackground && d_textureNames[TEXTURE_BACKGROUND] && !g_viewerSettings.showTexture )
{
m_projection.CreateOrtho( 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f );
SetProjectionMatrix( m_projection );
ResetModelviewMatrix();
glDisable( GL_CULL_FACE );
glEnable( GL_TEXTURE_2D );
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glBindTexture( GL_TEXTURE_2D, d_textureNames[TEXTURE_BACKGROUND] );
glBegin( GL_TRIANGLE_STRIP );
glTexCoord2f( 0, 0 );
glVertex2f( 0, 0 );
glTexCoord2f( 1, 0 );
glVertex2f( 1, 0 );
glTexCoord2f( 0, 1 );
glVertex2f( 0, 1 );
glTexCoord2f( 1, 1 );
glVertex2f( 1, 1 );
glEnd();
glClear( GL_DEPTH_BUFFER_BIT );
glBindTexture( GL_TEXTURE_2D, 0 );
}
// calc viewer FOV
float fov_x = (bUseWeaponOrigin) ? 68.0f : 65.0f; // same as original
float fov_y = V_CalcFov( fov_x, w(), h() );
// NOTE: GluPerspective receives fov_y as input but original code sent fov_x
// this is completely wrong but i'm leave it for backward compatibility
GluPerspective( fov_x );
if( bUseWeaponOrigin )
{
m_modelview.CreateModelview(); // init quake world orientation
m_modelview.ConcatTranslate( 1.0f, 0.0f, -1.0f ); // shift back like in HL
vectors = matrix3x3( Vector( 90.0f, 0.0f, 0.0f ));
}
else
{
m_modelview.Identity();
m_modelview.ConcatTranslate( -g_viewerSettings.trans[0], -g_viewerSettings.trans[1], -g_viewerSettings.trans[2] );
m_modelview.ConcatRotate( g_viewerSettings.rot[0], 1, 0, 0 );
m_modelview.ConcatRotate( g_viewerSettings.rot[1], 0, 0, 1 );
vectors = matrix3x3( Vector( 180.0f - g_viewerSettings.rot[0], 270.0f - g_viewerSettings.rot[1], 0.0f ));
}
SetModelviewMatrix( m_modelview );
// setup stencil buffer
if( g_viewerSettings.useStencil && !bUseWeaponOrigin )
{
// Don't update color or depth.
glDisable( GL_DEPTH_TEST );
glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
// Draw 1 into the stencil buffer.
glEnable( GL_STENCIL_TEST );
glStencilOp( GL_KEEP, GL_KEEP, GL_REPLACE );
glStencilFunc( GL_ALWAYS, 1, 0xffffffff );
// Now render floor; floor pixels just get their stencil set to 1.
drawFloor();
// Re-enable update of color and depth.
glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
glEnable( GL_DEPTH_TEST );
// Now, only render where stencil is set to 1.
glStencilFunc( GL_EQUAL, 1, 0xffffffff ); // draw if == 1
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
}
if( g_viewerSettings.mirror && !bUseWeaponOrigin )
{
const GLdouble flClipPlane[] = { 0.0, 0.0, -1.0, 0.0 };
setupRenderMode();
glCullFace( GL_BACK );
glEnable( GL_CLIP_PLANE0 );
glClipPlane( GL_CLIP_PLANE0, flClipPlane );
g_studioModel.DrawModel( true );
glDisable( GL_CLIP_PLANE0 );
}
g_viewerSettings.drawn_polys = 0;
if( g_viewerSettings.useStencil )
glDisable( GL_STENCIL_TEST );
setupRenderMode();
if( bUseWeaponOrigin && bUseWeaponLeftHand )
glCullFace( GL_BACK );
else glCullFace( GL_FRONT );
g_studioModel.DrawModel();
//
// draw ground
//
if( g_viewerSettings.showGround && !bUseWeaponOrigin )
{
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glEnable( GL_DEPTH_TEST );
glEnable( GL_CULL_FACE );
if( g_viewerSettings.useStencil )
glFrontFace( GL_CW );
else glDisable( GL_CULL_FACE );
glEnable( GL_BLEND );
if( !d_textureNames[TEXTURE_GROUND] )
{
glDisable( GL_TEXTURE_2D );
glColor4f( g_viewerSettings.gColor[0], g_viewerSettings.gColor[1], g_viewerSettings.gColor[2], 0.7f );
glBindTexture( GL_TEXTURE_2D, 0 );
}
else
{
glEnable( GL_TEXTURE_2D );
glColor4f( 1.0f, 1.0f, 1.0f, 0.6f );
glBindTexture( GL_TEXTURE_2D, d_textureNames[TEXTURE_GROUND] );
}
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
drawFloor( d_textureNames[TEXTURE_GROUND] );
glDisable( GL_BLEND );
if( g_viewerSettings.useStencil )
{
glCullFace( GL_BACK );
glColor4f( 0.1f, 0.1f, 0.1f, 1.0f );
glBindTexture( GL_TEXTURE_2D, 0 );
drawFloor();
glFrontFace( GL_CCW );
}
else glEnable( GL_CULL_FACE );
}
if( bUseWeaponOrigin )
{
float hW = (float)w2() / 2;
float hH = (float)h2() / 2;
float flColor = 1.0f;
int dir = 5;
m_projection.CreateOrtho( 0.0f, w2(), h2(), 0.0f, 1.0f, -1.0f );
SetProjectionMatrix( m_projection );
glDisable( GL_MULTISAMPLE );
glDisable( GL_TEXTURE_2D );
ResetModelviewMatrix();
glColor4f( 1.0f, flColor, flColor, 0.8f );
glBegin( GL_LINES );
glVertex3f( hW, hH - dir, 0.0f );
glVertex3f( hW, hH - ( CROSS_LENGTH * 1.2f ) - dir, 0.0f );
glEnd();
glBegin( GL_LINES );
glVertex3f( hW + dir, hH + dir, 0.0f );
glVertex3f( hW + CROSS_LENGTH + dir, hH + CROSS_LENGTH + dir, 0.0f );
glEnd();
glBegin( GL_LINES );
glVertex3f( hW - dir, hH + dir, 0.0f );
glVertex3f( hW - CROSS_LENGTH - dir, hH + CROSS_LENGTH + dir, 0.0f );
glEnd();
glEnable( GL_TEXTURE_2D );
}
g_studioModel.incrementFramecounter();
}
int GlWindow :: loadTextureImage( mxImage *image, int name )
{
if( image )
{
d_textureNames[name] = name;
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
glPixelStorei( GL_PACK_ALIGNMENT, 1 );
if( image->bpp == 8 )
{
mstudiotexture_t texture;
texture.width = image->width;
texture.height = image->height;
texture.flags = 0;
g_studioModel.UploadTexture( &texture, (byte *)image->data, (byte *)image->palette, name );
}
else if( image->bpp == 24 )
{
glBindTexture( GL_TEXTURE_2D, d_textureNames[name] );
glHint( GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST );
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE );
glTexImage2D( GL_TEXTURE_2D, 0, 3, image->width, image->height, 0, GL_RGB, GL_UNSIGNED_BYTE, image->data );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
const char *extensions = (const char *)glGetString( GL_EXTENSIONS );
// check for anisotropy support
if( Q_strstr( extensions, "GL_EXT_texture_filter_anisotropic" ))
{
float anisotropy = 1.0f;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy );
}
}
else if( image->bpp == 32 )
{
glBindTexture( GL_TEXTURE_2D, d_textureNames[name] );
glHint( GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST );
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE );
glTexImage2D( GL_TEXTURE_2D, 0, 4, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->data );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
const char *extensions = (const char *)glGetString( GL_EXTENSIONS );
// check for anisotropy support
if( Q_strstr( extensions, "GL_EXT_texture_filter_anisotropic" ))
{
float anisotropy = 1.0f;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy );
}
}
delete image;
return name;
}
return TEXTURE_UNUSED;
}
int GlWindow :: loadTexture( const char *filename, int name )
{
if( !filename || !strlen( filename ))
{
if( d_textureNames[name] )
{
glDeleteTextures( 1, (const GLuint *)&d_textureNames[name] );
d_textureNames[name] = TEXTURE_UNUSED;
if( name == TEXTURE_BACKGROUND )
strcpy( g_viewerSettings.backgroundTexFile, "" );
else if( name == TEXTURE_GROUND )
strcpy( g_viewerSettings.groundTexFile, "" );
}
return TEXTURE_UNUSED;
}
mxImage *image = NULL;
char ext[16];
strcpy( ext, mx_getextension( filename ));
if( !mx_strcasecmp( ext, ".tga" ))
image = mxTgaRead( filename );
else if( !mx_strcasecmp( ext, ".pcx" ))
image = mxPcxRead( filename );
else if( !mx_strcasecmp( ext, ".bmp" ))
image = mxBmpRead( filename );
if( image )
{
if( name == TEXTURE_BACKGROUND )
strcpy( g_viewerSettings.backgroundTexFile, filename );
else if( name == TEXTURE_GROUND )
strcpy( g_viewerSettings.groundTexFile, filename );
}
return loadTextureImage( image, name );
}
int GlWindow :: loadTextureBuffer( const byte *buffer, size_t size, int name )
{
if( !buffer || size <= 0 )
{
if( d_textureNames[name] )
{
glDeleteTextures( 1, (const GLuint *)&d_textureNames[name] );
d_textureNames[name] = TEXTURE_UNUSED;
}
return TEXTURE_UNUSED;
}
mxImage *image = NULL;
image = mxBmpReadBuffer( buffer, size );
return loadTextureImage( image, name );
}
void GlWindow :: dumpViewport( const char *filename )
{
redraw();
int w = w2();
int h = h2();
mxImage *image = new mxImage ();
if( image->create( w, h, 24 ))
{
glReadBuffer( GL_FRONT );
glReadPixels( 0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, image->data );
image->flip_vertical();
if( !mxBmpWrite( filename, image ))
mxMessageBox( this, "Error writing screenshot.", g_appTitle, MX_MB_OK|MX_MB_ERROR );
delete image;
}
}
Reference in New Issue View Git Blame Copy Permalink