mirror of
https://github.com/FWGS/xash3d-fwgs.git
synced 2026-08-05 19:45:05 +08:00
578 lines
10 KiB
C
578 lines
10 KiB
C
/*
|
|
gu_triapi.c - TriAPI draw methods
|
|
Copyright (C) 2011 Uncle Mike
|
|
Copyright (C) 2019 a1batross
|
|
Copyright (C) 2021 Sergey Galushko
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "gu_local.h"
|
|
#include "const.h"
|
|
|
|
static struct
|
|
{
|
|
int renderMode; // override kRenderMode from TriAPI
|
|
vec4_t triRGBA;
|
|
} ds;
|
|
|
|
/*
|
|
===============================================================
|
|
|
|
TRIAPI IMPLEMENTATION
|
|
|
|
===============================================================
|
|
*/
|
|
#if 1
|
|
static struct
|
|
{
|
|
void *start;
|
|
gu_vert_ftcv_t *list;
|
|
qboolean begin;
|
|
int count;
|
|
int prim;
|
|
unsigned int flags;
|
|
}tri_gucontext =
|
|
{
|
|
.start = NULL,
|
|
.list = NULL,
|
|
.begin = false,
|
|
.count = 0,
|
|
.prim = 0,
|
|
.flags = 0
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
=============
|
|
TriRenderMode
|
|
|
|
set rendermode
|
|
=============
|
|
*/
|
|
void TriRenderMode( int mode )
|
|
{
|
|
#if 1
|
|
ds.renderMode = mode;
|
|
switch( mode )
|
|
{
|
|
case kRenderNormal:
|
|
sceGuTexFunc( GU_TFX_MODULATE, GU_TCC_RGBA );
|
|
sceGuDisable( GU_BLEND );
|
|
sceGuDepthMask( GU_FALSE );
|
|
break;
|
|
case kRenderTransAlpha:
|
|
sceGuEnable( GU_BLEND );
|
|
sceGuTexFunc( GU_TFX_MODULATE, GU_TCC_RGBA );
|
|
sceGuBlendFunc( GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );
|
|
sceGuDepthMask( GU_TRUE );
|
|
break;
|
|
case kRenderTransColor:
|
|
case kRenderTransTexture:
|
|
sceGuEnable( GU_BLEND );
|
|
sceGuBlendFunc( GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );
|
|
break;
|
|
case kRenderGlow:
|
|
case kRenderTransAdd:
|
|
sceGuBlendFunc( GU_ADD, GU_SRC_ALPHA, GU_FIX, 0, GUBLEND1 );
|
|
sceGuEnable( GU_BLEND );
|
|
sceGuDepthMask( GU_TRUE );
|
|
break;
|
|
}
|
|
#else
|
|
ds.renderMode = mode;
|
|
switch( mode )
|
|
{
|
|
case kRenderNormal:
|
|
pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglDisable( GL_BLEND );
|
|
pglDepthMask( GL_TRUE );
|
|
break;
|
|
case kRenderTransAlpha:
|
|
pglEnable( GL_BLEND );
|
|
pglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
pglDepthMask( GL_FALSE );
|
|
break;
|
|
case kRenderTransColor:
|
|
case kRenderTransTexture:
|
|
pglEnable( GL_BLEND );
|
|
pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
break;
|
|
case kRenderGlow:
|
|
case kRenderTransAdd:
|
|
pglBlendFunc( GL_SRC_ALPHA, GL_ONE );
|
|
pglEnable( GL_BLEND );
|
|
pglDepthMask( GL_FALSE );
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriBegin
|
|
|
|
begin triangle sequence
|
|
=============
|
|
*/
|
|
void TriBegin( int mode )
|
|
{
|
|
#if 1
|
|
switch( mode )
|
|
{
|
|
case TRI_POINTS:
|
|
tri_gucontext.prim = GU_POINTS;
|
|
break;
|
|
case TRI_TRIANGLES:
|
|
tri_gucontext.prim = GU_TRIANGLES;
|
|
break;
|
|
case TRI_TRIANGLE_FAN:
|
|
tri_gucontext.prim = GU_TRIANGLE_FAN;
|
|
break;
|
|
case TRI_QUADS:
|
|
tri_gucontext.prim = GU_TRIANGLE_FAN;
|
|
break;
|
|
case TRI_LINES:
|
|
tri_gucontext.prim = GU_LINES;
|
|
break;
|
|
case TRI_TRIANGLE_STRIP:
|
|
tri_gucontext.prim = GU_TRIANGLE_STRIP;
|
|
break;
|
|
case TRI_QUAD_STRIP:
|
|
tri_gucontext.prim = GU_TRIANGLE_STRIP;
|
|
break;
|
|
case TRI_POLYGON:
|
|
default:
|
|
tri_gucontext.prim = GU_TRIANGLE_FAN;
|
|
break;
|
|
}
|
|
tri_gucontext.start = extGuBeginPacket( NULL );
|
|
tri_gucontext.list = ( gu_vert_ftcv_t* )tri_gucontext.start;
|
|
tri_gucontext.begin = true;
|
|
tri_gucontext.count = 0;
|
|
tri_gucontext.flags = 0;
|
|
#else
|
|
switch( mode )
|
|
{
|
|
case TRI_POINTS:
|
|
mode = GL_POINTS;
|
|
break;
|
|
case TRI_TRIANGLES:
|
|
mode = GL_TRIANGLES;
|
|
break;
|
|
case TRI_TRIANGLE_FAN:
|
|
mode = GL_TRIANGLE_FAN;
|
|
break;
|
|
case TRI_QUADS:
|
|
mode = GL_QUADS;
|
|
break;
|
|
case TRI_LINES:
|
|
mode = GL_LINES;
|
|
break;
|
|
case TRI_TRIANGLE_STRIP:
|
|
mode = GL_TRIANGLE_STRIP;
|
|
break;
|
|
case TRI_QUAD_STRIP:
|
|
mode = GL_QUAD_STRIP;
|
|
break;
|
|
case TRI_POLYGON:
|
|
default:
|
|
mode = GL_POLYGON;
|
|
break;
|
|
}
|
|
|
|
pglBegin( mode );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriEnd
|
|
|
|
draw triangle sequence
|
|
=============
|
|
*/
|
|
void TriEnd( void )
|
|
{
|
|
#if 1
|
|
unsigned int vert_size;
|
|
|
|
if( !tri_gucontext.begin )
|
|
return;
|
|
|
|
extGuEndPacket( ( void* )tri_gucontext.list );
|
|
sceGuDrawArray( tri_gucontext.prim, tri_gucontext.flags, tri_gucontext.count, 0, tri_gucontext.start );
|
|
|
|
tri_gucontext.begin = false;
|
|
#else
|
|
pglEnd( );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
_TriColor4f
|
|
|
|
=============
|
|
*/
|
|
void _TriColor4f( float r, float g, float b, float a )
|
|
{
|
|
#if 1
|
|
if( tri_gucontext.begin )
|
|
{
|
|
tri_gucontext.flags |= GU_COLOR_8888;
|
|
tri_gucontext.list->c = GUCOLOR4F( r, g, b, a );
|
|
}
|
|
else
|
|
{
|
|
sceGuColor( GUCOLOR4F( r, g, b, a ) );
|
|
}
|
|
#else
|
|
pglColor4f( r, g, b, a );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
_TriColor4ub
|
|
|
|
=============
|
|
*/
|
|
void _TriColor4ub( byte r, byte g, byte b, byte a )
|
|
{
|
|
#if 1
|
|
if( tri_gucontext.begin )
|
|
{
|
|
tri_gucontext.flags |= GU_COLOR_8888;
|
|
tri_gucontext.list->c = GUCOLOR4UB( r, g, b, a );
|
|
}
|
|
else
|
|
{
|
|
sceGuColor( GUCOLOR4UB( r, g, b, a ) );
|
|
}
|
|
#else
|
|
pglColor4ub( r, g, b, a );
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
TriColor4ub
|
|
|
|
=============
|
|
*/
|
|
void TriColor4ub( byte r, byte g, byte b, byte a )
|
|
{
|
|
ds.triRGBA[0] = r * (1.0f / 255.0f);
|
|
ds.triRGBA[1] = g * (1.0f / 255.0f);
|
|
ds.triRGBA[2] = b * (1.0f / 255.0f);
|
|
ds.triRGBA[3] = a * (1.0f / 255.0f);
|
|
|
|
_TriColor4f( ds.triRGBA[0], ds.triRGBA[1], ds.triRGBA[2], 1.0f );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
TriColor4f
|
|
=================
|
|
*/
|
|
void TriColor4f( float r, float g, float b, float a )
|
|
{
|
|
if( ds.renderMode == kRenderTransAlpha )
|
|
TriColor4ub( r * 255.0f, g * 255.0f, b * 255.0f, a * 255.0f );
|
|
else _TriColor4f( r * a, g * a, b * a, 1.0 );
|
|
|
|
ds.triRGBA[0] = r;
|
|
ds.triRGBA[1] = g;
|
|
ds.triRGBA[2] = b;
|
|
ds.triRGBA[3] = a;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriTexCoord2f
|
|
|
|
=============
|
|
*/
|
|
void TriTexCoord2f( float u, float v )
|
|
{
|
|
#if 1
|
|
if( !tri_gucontext.begin )
|
|
return;
|
|
|
|
tri_gucontext.flags |= GU_TEXTURE_32BITF;
|
|
tri_gucontext.list->u = u;
|
|
tri_gucontext.list->v = v;
|
|
#else
|
|
pglTexCoord2f( u, v );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriVertex3fv
|
|
|
|
=============
|
|
*/
|
|
void TriVertex3fv( const float *v )
|
|
{
|
|
#if 1
|
|
if( !tri_gucontext.begin )
|
|
return;
|
|
|
|
if( !(tri_gucontext.flags & GU_TEXTURE_32BITF) )
|
|
{
|
|
tri_gucontext.list->u = 0;
|
|
tri_gucontext.list->v = 0;
|
|
}
|
|
|
|
if( !(tri_gucontext.flags & GU_COLOR_8888) )
|
|
{
|
|
tri_gucontext.list->c = 0xffffffff;
|
|
}
|
|
|
|
tri_gucontext.flags |= GU_VERTEX_32BITF;
|
|
tri_gucontext.list->x = v[0];
|
|
tri_gucontext.list->y = v[1];
|
|
tri_gucontext.list->z = v[2];
|
|
tri_gucontext.list++;
|
|
|
|
tri_gucontext.count++;
|
|
#else
|
|
pglVertex3fv( v );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriVertex3f
|
|
|
|
=============
|
|
*/
|
|
void TriVertex3f( float x, float y, float z )
|
|
{
|
|
#if 1
|
|
if( !tri_gucontext.begin )
|
|
return;
|
|
|
|
if( !(tri_gucontext.flags & GU_TEXTURE_32BITF) )
|
|
{
|
|
tri_gucontext.list->u = 0;
|
|
tri_gucontext.list->v = 0;
|
|
}
|
|
|
|
if( !(tri_gucontext.flags & GU_COLOR_8888) )
|
|
{
|
|
tri_gucontext.list->c = 0xffffffff;
|
|
}
|
|
|
|
tri_gucontext.flags |= GU_VERTEX_32BITF;
|
|
tri_gucontext.list->x = x;
|
|
tri_gucontext.list->y = y;
|
|
tri_gucontext.list->z = z;
|
|
tri_gucontext.list++;
|
|
|
|
tri_gucontext.count++;
|
|
#else
|
|
pglVertex3f( x, y, z );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriWorldToScreen
|
|
|
|
convert world coordinates (x,y,z) into screen (x, y)
|
|
=============
|
|
*/
|
|
int TriWorldToScreen( const float *world, float *screen )
|
|
{
|
|
int retval;
|
|
|
|
retval = R_WorldToScreen( world, screen );
|
|
|
|
screen[0] = 0.5f * screen[0] * (float)RI.viewport[2];
|
|
screen[1] = -0.5f * screen[1] * (float)RI.viewport[3];
|
|
screen[0] += 0.5f * (float)RI.viewport[2];
|
|
screen[1] += 0.5f * (float)RI.viewport[3];
|
|
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriSpriteTexture
|
|
|
|
bind current texture
|
|
=============
|
|
*/
|
|
int TriSpriteTexture( model_t *pSpriteModel, int frame )
|
|
{
|
|
int gl_texturenum;
|
|
|
|
if(( gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame )) == 0 )
|
|
return 0;
|
|
|
|
if( gl_texturenum <= 0 || gl_texturenum > MAX_TEXTURES )
|
|
gl_texturenum = tr.defaultTexture;
|
|
|
|
GL_Bind( XASH_TEXTURE0, gl_texturenum );
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriFog
|
|
|
|
enables global fog on the level
|
|
=============
|
|
*/
|
|
void TriFog( float flFogColor[3], float flStart, float flEnd, int bOn )
|
|
{
|
|
// overrided by internal fog
|
|
if( RI.fogEnabled ) return;
|
|
RI.fogCustom = bOn;
|
|
|
|
// check for invalid parms
|
|
if( flEnd <= flStart )
|
|
{
|
|
glState.isFogEnabled = RI.fogCustom = false;
|
|
#if 1
|
|
sceGuDisable( GU_FOG );
|
|
#else
|
|
pglDisable( GL_FOG );
|
|
#endif
|
|
return;
|
|
}
|
|
#if 1
|
|
if( RI.fogCustom )
|
|
sceGuEnable( GU_FOG );
|
|
else sceGuDisable( GU_FOG );
|
|
#else
|
|
if( RI.fogCustom )
|
|
pglEnable( GL_FOG );
|
|
else pglDisable( GL_FOG );
|
|
#endif
|
|
// copy fog params
|
|
RI.fogColor[0] = flFogColor[0] / 255.0f;
|
|
RI.fogColor[1] = flFogColor[1] / 255.0f;
|
|
RI.fogColor[2] = flFogColor[2] / 255.0f;
|
|
RI.fogStart = flStart;
|
|
RI.fogColor[3] = 1.0f;
|
|
RI.fogDensity = 0.0f;
|
|
RI.fogSkybox = true;
|
|
RI.fogEnd = flEnd;
|
|
|
|
#if 1
|
|
printf("TRI FOG: s %f e %f c %f %f %f %f \n", RI.fogStart, RI.fogEnd,
|
|
RI.fogColor[0], RI.fogColor[1], RI.fogColor[2], RI.fogColor[3] );
|
|
|
|
//glState.fogDensity = RI.fogDensity
|
|
glState.fogColor = GUCOLOR4F( RI.fogColor[0], RI.fogColor[1], RI.fogColor[2], glState.fogDensity );
|
|
glState.fogStart = RI.fogStart;
|
|
glState.fogEnd = RI.fogEnd;
|
|
|
|
sceGuFog( glState.fogStart, glState.fogEnd, glState.fogColor );
|
|
#else
|
|
pglFogi( GL_FOG_MODE, GL_LINEAR );
|
|
pglFogfv( GL_FOG_COLOR, RI.fogColor );
|
|
pglFogf( GL_FOG_START, RI.fogStart );
|
|
pglFogf( GL_FOG_END, RI.fogEnd );
|
|
pglHint( GL_FOG_HINT, GL_NICEST );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriGetMatrix
|
|
|
|
very strange export
|
|
=============
|
|
*/
|
|
void TriGetMatrix( const int pname, float *matrix )
|
|
{
|
|
#if 1
|
|
printf("%s:%i:%s - Not implemented\n", __FILE__, __LINE__, __FUNCTION__ );
|
|
#else
|
|
pglGetFloatv( pname, matrix );
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriForParams
|
|
|
|
=============
|
|
*/
|
|
void TriFogParams( float flDensity, int iFogSkybox )
|
|
{
|
|
RI.fogDensity = flDensity;
|
|
RI.fogSkybox = iFogSkybox;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriCullFace
|
|
|
|
=============
|
|
*/
|
|
void TriCullFace( TRICULLSTYLE mode )
|
|
{
|
|
int glMode;
|
|
|
|
switch( mode )
|
|
{
|
|
case TRI_FRONT:
|
|
glMode = GL_FRONT;
|
|
break;
|
|
default:
|
|
glMode = GL_NONE;
|
|
break;
|
|
}
|
|
|
|
GL_Cull( mode );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
TriBrightness
|
|
=============
|
|
*/
|
|
void TriBrightness( float brightness )
|
|
{
|
|
float r, g, b;
|
|
|
|
r = ds.triRGBA[0] * ds.triRGBA[3] * brightness;
|
|
g = ds.triRGBA[1] * ds.triRGBA[3] * brightness;
|
|
b = ds.triRGBA[2] * ds.triRGBA[3] * brightness;
|
|
|
|
_TriColor4f( r, g, b, 1.0f );
|
|
}
|
|
|
|
unsigned int getTriBrightness( float brightness )
|
|
{
|
|
vec3_t color;
|
|
|
|
if(brightness < 0.0f) return 0;
|
|
|
|
color[0] = ds.triRGBA[0] * ds.triRGBA[3] * brightness;
|
|
color[1] = ds.triRGBA[1] * ds.triRGBA[3] * brightness;
|
|
color[2] = ds.triRGBA[2] * ds.triRGBA[3] * brightness;
|
|
|
|
VectorNormalizeFast( color );
|
|
|
|
return GUCOLOR3FV( color );
|
|
}
|
|
|