mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-10-05 23:44:51 +02:00
328 lines
11 KiB
C++
328 lines
11 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd.
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of version 2 of the GNU General Public License as published by
|
|
the Free Software Foundation
|
|
|
|
|
|
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.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
|
|
|
|
#include "Engine/StdH.h"
|
|
|
|
#include <Engine/Graphics/GfxLibrary.h>
|
|
|
|
#include <Engine/Base/Statistics_Internal.h>
|
|
#include <Engine/Math/Functions.h>
|
|
#include <Engine/Graphics/Color.h>
|
|
#include <Engine/Graphics/OpenGL.h>
|
|
#include <Engine/Graphics/Texture.h>
|
|
#include <Engine/Graphics/GfxProfile.h>
|
|
|
|
#include <Engine/Base/ListIterator.inl>
|
|
|
|
// asm shortcuts
|
|
#define O offset
|
|
#define Q qword ptr
|
|
#define D dword ptr
|
|
#define W word ptr
|
|
#define B byte ptr
|
|
|
|
|
|
// we need array for OpenGL mipmaps that are lower than N*1 or 1*N
|
|
static ULONG _aulLastMipmaps[(INDEX)(1024*1.334)];
|
|
static CTexParams *_tpCurrent;
|
|
extern INDEX GFX_iActiveTexUnit;
|
|
|
|
// unpacks texture filering from one INDEX to two GLenums (and eventually re-adjust input INDEX)
|
|
static void UnpackFilter_OGL( INDEX iFilter, GLenum &eMagFilter, GLenum &eMinFilter)
|
|
{
|
|
switch( iFilter) {
|
|
case 110: case 10: eMagFilter=GL_NEAREST; eMinFilter=GL_NEAREST; break;
|
|
case 111: case 11: eMagFilter=GL_NEAREST; eMinFilter=GL_NEAREST_MIPMAP_NEAREST; break;
|
|
case 112: case 12: eMagFilter=GL_NEAREST; eMinFilter=GL_NEAREST_MIPMAP_LINEAR; break;
|
|
case 220: case 20: eMagFilter=GL_LINEAR; eMinFilter=GL_LINEAR; break;
|
|
case 221: case 21: eMagFilter=GL_LINEAR; eMinFilter=GL_LINEAR_MIPMAP_NEAREST; break;
|
|
case 222: case 22: eMagFilter=GL_LINEAR; eMinFilter=GL_LINEAR_MIPMAP_LINEAR; break;
|
|
case 120: eMagFilter=GL_NEAREST; eMinFilter=GL_LINEAR; break;
|
|
case 121: eMagFilter=GL_NEAREST; eMinFilter=GL_LINEAR_MIPMAP_NEAREST; break;
|
|
case 122: eMagFilter=GL_NEAREST; eMinFilter=GL_LINEAR_MIPMAP_LINEAR; break;
|
|
case 210: eMagFilter=GL_LINEAR; eMinFilter=GL_NEAREST; break;
|
|
case 211: eMagFilter=GL_LINEAR; eMinFilter=GL_NEAREST_MIPMAP_NEAREST; break;
|
|
case 212: eMagFilter=GL_LINEAR; eMinFilter=GL_NEAREST_MIPMAP_LINEAR; break;
|
|
default: ASSERTALWAYS( "Illegal OpenGL texture filtering mode."); break;
|
|
}
|
|
}
|
|
|
|
|
|
// change texture filtering mode if needed
|
|
extern void MimicTexParams_OGL( CTexParams &tpLocal)
|
|
{
|
|
ASSERT( &tpLocal!=NULL);
|
|
_pfGfxProfile.StartTimer( CGfxProfile::PTI_TEXTUREPARAMS);
|
|
|
|
// set texture filtering mode if required
|
|
if( tpLocal.tp_iFilter != _tpGlobal[0].tp_iFilter)
|
|
{ // update OpenGL texture filters
|
|
GLenum eMagFilter, eMinFilter;
|
|
UnpackFilter_OGL( _tpGlobal[0].tp_iFilter, eMagFilter, eMinFilter);
|
|
// adjust minimize filter in case of a single mipmap
|
|
if( tpLocal.tp_bSingleMipmap) {
|
|
if( eMinFilter==GL_NEAREST_MIPMAP_NEAREST || eMinFilter==GL_NEAREST_MIPMAP_LINEAR) eMinFilter = GL_NEAREST;
|
|
else if( eMinFilter==GL_LINEAR_MIPMAP_NEAREST || eMinFilter==GL_LINEAR_MIPMAP_LINEAR) eMinFilter = GL_LINEAR;
|
|
}
|
|
// update texture filter
|
|
pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, eMagFilter);
|
|
pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, eMinFilter);
|
|
tpLocal.tp_iFilter = _tpGlobal[0].tp_iFilter;
|
|
OGL_CHECKERROR;
|
|
}
|
|
|
|
// set texture anisotropy degree if required and supported
|
|
if( tpLocal.tp_iAnisotropy != _tpGlobal[0].tp_iAnisotropy) {
|
|
tpLocal.tp_iAnisotropy = _tpGlobal[0].tp_iAnisotropy;
|
|
if( _pGfx->gl_iMaxTextureAnisotropy>=2) { // only if allowed
|
|
pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, tpLocal.tp_iAnisotropy);
|
|
}
|
|
}
|
|
|
|
// set texture clamping modes if changed
|
|
if( tpLocal.tp_eWrapU!=_tpGlobal[GFX_iActiveTexUnit].tp_eWrapU
|
|
|| tpLocal.tp_eWrapV!=_tpGlobal[GFX_iActiveTexUnit].tp_eWrapV)
|
|
{ // prepare temp vars
|
|
GLuint eWrapU = _tpGlobal[GFX_iActiveTexUnit].tp_eWrapU==GFX_REPEAT ? GL_REPEAT : GL_CLAMP;
|
|
GLuint eWrapV = _tpGlobal[GFX_iActiveTexUnit].tp_eWrapV==GFX_REPEAT ? GL_REPEAT : GL_CLAMP;
|
|
// eventually re-adjust clamping params in case of clamp_to_edge extension
|
|
if( _pGfx->gl_ulFlags&GLF_EXT_EDGECLAMP) {
|
|
if( eWrapU == GL_CLAMP) eWrapU = GL_CLAMP_TO_EDGE;
|
|
if( eWrapV == GL_CLAMP) eWrapV = GL_CLAMP_TO_EDGE;
|
|
}
|
|
// set clamping params and update local texture clamping modes
|
|
pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, eWrapU);
|
|
pglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, eWrapV);
|
|
tpLocal.tp_eWrapU = _tpGlobal[GFX_iActiveTexUnit].tp_eWrapU;
|
|
tpLocal.tp_eWrapV = _tpGlobal[GFX_iActiveTexUnit].tp_eWrapV;
|
|
OGL_CHECKERROR;
|
|
}
|
|
|
|
// keep last texture params (for tex upload and stuff)
|
|
_tpCurrent = &tpLocal;
|
|
_pfGfxProfile.StopTimer( CGfxProfile::PTI_TEXTUREPARAMS);
|
|
}
|
|
|
|
|
|
|
|
// upload context for current texture to accelerator's memory
|
|
// (returns format in which texture was really uploaded)
|
|
void UploadTexture_OGL( ULONG *pulTexture, PIX pixSizeU, PIX pixSizeV,
|
|
GLenum eInternalFormat, BOOL bUseSubImage)
|
|
{
|
|
// safeties
|
|
ASSERT( pulTexture!=NULL);
|
|
ASSERT( pixSizeU>0 && pixSizeV>0);
|
|
_sfStats.StartTimer( CStatForm::STI_BINDTEXTURE);
|
|
_pfGfxProfile.StartTimer( CGfxProfile::PTI_TEXTUREUPLOADING);
|
|
|
|
// upload each original mip-map
|
|
INDEX iMip=0;
|
|
PIX pixOffset=0;
|
|
while( pixSizeU>0 && pixSizeV>0)
|
|
{
|
|
#if 0 // trust me, you'll know if it's not readable. :) This assert will read one past the start of the array if U or V is zero, so turning it off. --ryan.
|
|
// check that memory is readable
|
|
ASSERT( pulTexture[pixOffset +pixSizeU*pixSizeV -1] != 0xDEADBEEF);
|
|
#endif
|
|
|
|
// upload mipmap as fast as possible
|
|
if( bUseSubImage) {
|
|
pglTexSubImage2D( GL_TEXTURE_2D, iMip, 0, 0, pixSizeU, pixSizeV,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, pulTexture+pixOffset);
|
|
} else {
|
|
pglTexImage2D( GL_TEXTURE_2D, iMip, eInternalFormat, pixSizeU, pixSizeV, 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, pulTexture+pixOffset);
|
|
} OGL_CHECKERROR;
|
|
// advance to next mip-map
|
|
pixOffset += pixSizeU*pixSizeV;
|
|
pixSizeU >>=1;
|
|
pixSizeV >>=1;
|
|
iMip++;
|
|
// end here if there is only one mip-map to upload
|
|
if( _tpCurrent->tp_bSingleMipmap) break;
|
|
}
|
|
|
|
// see if we need to generate and upload additional mipmaps (those under 1*N or N*1)
|
|
if( !_tpCurrent->tp_bSingleMipmap && pixSizeU!=pixSizeV)
|
|
{ // prepare variables
|
|
PIX pixSize = Max(pixSizeU,pixSizeV);
|
|
ASSERT( pixSize<=2048);
|
|
ULONG *pulSrc = pulTexture+pixOffset-pixSize*2;
|
|
ULONG *pulDst = _aulLastMipmaps;
|
|
// loop thru mipmaps
|
|
while( pixSizeU>0 || pixSizeV>0)
|
|
{ // make next mipmap
|
|
if( pixSizeU==0) pixSizeU=1;
|
|
if( pixSizeV==0) pixSizeV=1;
|
|
pixSize = pixSizeU*pixSizeV;
|
|
|
|
#if (defined USE_PORTABLE_C)
|
|
// Basically average every other pixel...
|
|
UWORD w = 0;
|
|
UBYTE *dptr = (UBYTE *) pulDst;
|
|
UBYTE *sptr = (UBYTE *) pulSrc;
|
|
#if 0
|
|
pixSize *= 4;
|
|
for (PIX i = 0; i < pixSize; i++)
|
|
{
|
|
*dptr = (UBYTE) ( (((UWORD) sptr[0]) + ((UWORD) sptr[1])) >> 1 );
|
|
dptr++;
|
|
sptr += 2;
|
|
}
|
|
#else
|
|
for (PIX i = 0; i < pixSize; i++)
|
|
{
|
|
for (PIX j = 0; j < 4; j++)
|
|
{
|
|
*dptr = (UBYTE) ( (((UWORD) sptr[0]) + ((UWORD) sptr[4])) >> 1 );
|
|
dptr++;
|
|
sptr++;
|
|
}
|
|
sptr += 4;
|
|
}
|
|
#endif
|
|
#elif (defined __MSVC_INLINE__)
|
|
__asm {
|
|
pxor mm0,mm0
|
|
mov esi,D [pulSrc]
|
|
mov edi,D [pulDst]
|
|
mov ecx,D [pixSize]
|
|
pixLoop:
|
|
movd mm1,D [esi+0]
|
|
movd mm2,D [esi+4]
|
|
punpcklbw mm1,mm0
|
|
punpcklbw mm2,mm0
|
|
paddw mm1,mm2
|
|
psrlw mm1,1
|
|
packuswb mm1,mm0
|
|
movd D [edi],mm1
|
|
add esi,4*2
|
|
add edi,4
|
|
dec ecx
|
|
jnz pixLoop
|
|
emms
|
|
}
|
|
|
|
#elif (defined __GNU_INLINE__)
|
|
__asm__ __volatile__ (
|
|
"pxor %%mm0,%%mm0 \n\t"
|
|
"0: \n\t" // pixLoop
|
|
"movd 0(%%esi), %%mm1 \n\t"
|
|
"movd 4(%%esi), %%mm2 \n\t"
|
|
"punpcklbw %%mm0,%%mm1 \n\t"
|
|
"punpcklbw %%mm0,%%mm2 \n\t"
|
|
"paddw %%mm2,%%mm1 \n\t"
|
|
"psrlw $1,%%mm1 \n\t"
|
|
"packuswb %%mm0,%%mm1 \n\t"
|
|
"movd %%mm1, (%%edi) \n\t"
|
|
"addl $8,%%esi \n\t"
|
|
"addl $4,%%edi \n\t"
|
|
"decl %%ecx \n\t"
|
|
"jnz 0b \n\t" // pixLoop
|
|
"emms \n\t"
|
|
:
|
|
: "S" (pulSrc), "D" (pulDst), "c" (pixSize)
|
|
: "memory", "cc"
|
|
);
|
|
|
|
#else
|
|
#error Please write inline ASM for your platform.
|
|
#endif
|
|
|
|
// upload mipmap
|
|
if( bUseSubImage) {
|
|
pglTexSubImage2D( GL_TEXTURE_2D, iMip, 0, 0, pixSizeU, pixSizeV,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, pulDst);
|
|
} else {
|
|
pglTexImage2D( GL_TEXTURE_2D, iMip, eInternalFormat, pixSizeU, pixSizeV, 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, pulDst);
|
|
} OGL_CHECKERROR;
|
|
// advance to next mip-map
|
|
pulSrc = pulDst;
|
|
pulDst += pixSize;
|
|
pixOffset += pixSize;
|
|
pixSizeU >>=1;
|
|
pixSizeV >>=1;
|
|
iMip++;
|
|
}
|
|
}
|
|
|
|
// all done
|
|
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_TEXTUREUPLOADS, 1);
|
|
_pfGfxProfile.IncrementCounter( CGfxProfile::PCI_TEXTUREUPLOADBYTES, pixOffset*4);
|
|
_sfStats.IncrementCounter( CStatForm::SCI_TEXTUREUPLOADS, 1);
|
|
_sfStats.IncrementCounter( CStatForm::SCI_TEXTUREUPLOADBYTES, pixOffset*4);
|
|
_pfGfxProfile.StopTimer( CGfxProfile::PTI_TEXTUREUPLOADING);
|
|
_sfStats.StopTimer( CStatForm::STI_BINDTEXTURE);
|
|
}
|
|
|
|
|
|
|
|
// returns bytes/pixels ratio for uploaded texture
|
|
extern INDEX GetFormatPixRatio_OGL( GLenum eFormat)
|
|
{
|
|
switch( eFormat) {
|
|
case GL_RGBA:
|
|
case GL_RGBA8:
|
|
return 4;
|
|
case GL_RGB:
|
|
case GL_RGB8:
|
|
return 3;
|
|
case GL_RGB5:
|
|
case GL_RGB5_A1:
|
|
case GL_RGB4:
|
|
case GL_RGBA4:
|
|
case GL_LUMINANCE_ALPHA:
|
|
case GL_LUMINANCE8_ALPHA8:
|
|
return 2;
|
|
// compressed formats and single-channel formats
|
|
default:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
// returns bytes/pixels ratio for uploaded texture
|
|
extern INDEX GetTexturePixRatio_OGL( GLuint uiBindNo)
|
|
{
|
|
GLenum eInternalFormat;
|
|
pglBindTexture( GL_TEXTURE_2D, uiBindNo);
|
|
pglGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&eInternalFormat);
|
|
OGL_CHECKERROR;
|
|
return GetFormatPixRatio_OGL( eInternalFormat);
|
|
}
|
|
|
|
|
|
// return allowed dithering method
|
|
extern INDEX AdjustDitheringType_OGL( GLenum eFormat, INDEX iDitheringType)
|
|
{
|
|
switch( eFormat) {
|
|
// these formats don't need dithering
|
|
case GL_RGB8:
|
|
case GL_RGBA8:
|
|
case GL_LUMINANCE8:
|
|
case GL_LUMINANCE8_ALPHA8:
|
|
return NONE;
|
|
// these formats need reduced dithering
|
|
case GL_RGB5:
|
|
case GL_RGB5_A1:
|
|
if( iDitheringType>7) return iDitheringType-3;
|
|
// other formats need dithering as it is
|
|
default:
|
|
return iDitheringType;
|
|
}
|
|
}
|