actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Readded texture stretch, texture dither, and 16 bit textures.

Browse Source
This commit is contained in:
Chris Danford
2002-11-14 01:26:19 +00:00
parent 9d68ff5d7b
commit 487b4e9527
16 changed files with 293 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
stepmania/src/BGAnimationLayer.cpp
+21 -17
View File
@@ -156,24 +156,28 @@ found_effect:
case EFFECT_STRETCH_WATER:
case EFFECT_STRETCH_BUBBLE:
case EFFECT_STRETCH_TWIST:
m_iNumSprites = 1;
m_Sprites[0].Load( sPath, false, 4, 4, false, true );
m_Sprites[0].StretchTo( RectI(SCREEN_LEFT,SCREEN_TOP,SCREEN_RIGHT,SCREEN_BOTTOM) );
m_Sprites[0].SetCustomTextureRect( RectF(0,0,1,1) );
switch( m_Effect )
{
case EFFECT_STRETCH_SCROLL_LEFT: m_vTexCoordVelocity = RageVector2(+0.5f,0); break;
case EFFECT_STRETCH_SCROLL_RIGHT: m_vTexCoordVelocity = RageVector2(-0.5f,0); break;
case EFFECT_STRETCH_SCROLL_UP: m_vTexCoordVelocity = RageVector2(0,+0.5f); break;
case EFFECT_STRETCH_SCROLL_DOWN: m_vTexCoordVelocity = RageVector2(0,-0.5f); break;
case EFFECT_STRETCH_WATER:
case EFFECT_STRETCH_BUBBLE:
case EFFECT_STRETCH_TWIST:
m_vTexCoordVelocity = RageVector2(-0.0f,0);
break;
default:
ASSERT(0);
m_iNumSprites = 1;
RageTexturePrefs prefs;
prefs.bStretch = true;
m_Sprites[0].Load( sPath, prefs );
m_Sprites[0].StretchTo( RectI(SCREEN_LEFT,SCREEN_TOP,SCREEN_RIGHT,SCREEN_BOTTOM) );
m_Sprites[0].SetCustomTextureRect( RectF(0,0,1,1) );
switch( m_Effect )
{
case EFFECT_STRETCH_SCROLL_LEFT: m_vTexCoordVelocity = RageVector2(+0.5f,0); break;
case EFFECT_STRETCH_SCROLL_RIGHT: m_vTexCoordVelocity = RageVector2(-0.5f,0); break;
case EFFECT_STRETCH_SCROLL_UP: m_vTexCoordVelocity = RageVector2(0,+0.5f); break;
case EFFECT_STRETCH_SCROLL_DOWN: m_vTexCoordVelocity = RageVector2(0,-0.5f); break;
case EFFECT_STRETCH_WATER:
case EFFECT_STRETCH_BUBBLE:
case EFFECT_STRETCH_TWIST:
m_vTexCoordVelocity = RageVector2(-0.0f,0);
break;
default:
ASSERT(0);
}
}
break;
case EFFECT_STRETCH_SPIN:
stepmania/src/Background.cpp
+5 -1
View File
@@ -174,7 +174,11 @@ void Background::LoadFromSong( Song* pSong )
// loader would have no way of knowing that the image, seeming to use the
// alpha layer, actually doesn't since it's the back-most image. Hmm.)
Sprite sprDummy;
sprDummy.Load( sSongBackgroundPath, true, 4, 0, true, false );
RageTexturePrefs prefs;
prefs.bForceReload = true;
prefs.iMipMaps = 1;
prefs.bDither = true;
sprDummy.Load( sSongBackgroundPath, prefs );
{
BGAnimation *pTempBGA = new BGAnimation;
stepmania/src/Banner.cpp
+5 -3
View File
@@ -25,10 +25,10 @@ Banner::Banner()
Banner::Load( THEME->GetPathTo("Graphics","fallback banner") );
}
bool Banner::Load( CString sFilePath, bool bForceReload, int iMipMaps, int iAlphaBits, bool bDither, bool bStretch )
bool Banner::Load( CString sFilePath, RageTexturePrefs prefs )
{
// note that the defaults are changes for faster loading
return CroppedSprite::Load( sFilePath, bForceReload, iMipMaps, iAlphaBits, bDither, bStretch );
return CroppedSprite::Load( sFilePath, prefs );
};
void Banner::Update( float fDeltaTime )
@@ -98,7 +98,9 @@ bool Banner::LoadFromCourse( Course* pCourse ) // NULL means no course
bool Banner::LoadRoulette()
{
Banner::Load( THEME->GetPathTo("Graphics","select music roulette banner"), false, 0, 0, false, false );
RageTexturePrefs prefs;
prefs.iMipMaps = 0;
Banner::Load( THEME->GetPathTo("Graphics","select music roulette banner"), prefs );
m_bScrolling = true;
return true;
stepmania/src/Banner.h
+2 -1
View File
@@ -20,7 +20,8 @@ class Banner : public CroppedSprite
public:
Banner();
virtual bool Load( CString sFilePath, bool bForceReload = false, int iMipMaps = 0, int iAlphaBits = 0, bool bDither = false, bool bStretch = false );
virtual bool Load( CString sFilePath, RageTexturePrefs prefs );
virtual bool Load( CString sFilePath ) { return Load( sFilePath, RageTexturePrefs() ); }
virtual void Update( float fDeltaTime );
stepmania/src/CroppedSprite.cpp
+2 -2
View File
@@ -21,9 +21,9 @@ CroppedSprite::CroppedSprite()
m_fCropWidth = m_fCropHeight = 100;
}
bool CroppedSprite::Load( CString sFilePath, bool bForceReload, int iMipMaps, int iAlphaBits, bool bDither, bool bStretch )
bool CroppedSprite::Load( CString sFilePath, RageTexturePrefs prefs )
{
Sprite::Load( sFilePath, bForceReload, iMipMaps, iAlphaBits, bDither, bStretch );
Sprite::Load( sFilePath, prefs );
CropToSize( m_fCropWidth, m_fCropHeight );
return true;
stepmania/src/CroppedSprite.h
+1 -2
View File
@@ -12,7 +12,6 @@
#include "Sprite.h"
#include "Song.h"
class CroppedSprite : public Sprite
@@ -21,7 +20,7 @@ public:
CroppedSprite();
virtual ~CroppedSprite() { }
bool Load( CString sFilePath, bool bForceReload = false, int iMipMaps = 4, int iAlphaBits = 4, bool bDither = false, bool bStretch = false );
bool Load( CString sFilePath, RageTexturePrefs prefs );
void SetCroppedSize( float fWidth, float fHeight );
protected:
stepmania/src/GrooveRadar.cpp
+7 -5
View File
@@ -10,21 +10,23 @@
-----------------------------------------------------------------------------
*/
#include "RageUtil.h"
#include "GrooveRadar.h"
#include "RageUtil.h"
#include "PrefsManager.h"
#include "RageBitmapTexture.h"
#include "GameConstantsAndTypes.h"
#include "ThemeManager.h"
#include "Notes.h"
#include "RageDisplay.h"
#include <math.h>
#define LABEL_OFFSET_X( i ) THEME->GetMetricF("GrooveRadar",ssprintf("Label%dOffsetX",i+1))
#define LABEL_OFFSET_Y( i ) THEME->GetMetricF("GrooveRadar",ssprintf("Label%dOffsetY",i+1))
float RADAR_VALUE_ROTATION( int iValueIndex ) { return D3DX_PI/2 + D3DX_PI*2 / 5.0f * iValueIndex; }
float RADAR_VALUE_ROTATION( int iValueIndex ) { return PI/2 + PI*2 / 5.0f * iValueIndex; }
const float RADAR_EDGE_WIDTH = 3;
@@ -203,7 +205,7 @@ void GrooveRadar::GrooveRadarValueMap::DrawPrimitives()
void GrooveRadar::GrooveRadarValueMap::TweenOnScreen()
{
SetZoom( 0.5f );
SetRotation( D3DX_PI*4 );
SetRotation( PI*4 );
BeginTweening( 0.6f );
SetTweenZoom( 1 );
SetTweenRotationZ( 0 );
@@ -212,6 +214,6 @@ void GrooveRadar::GrooveRadarValueMap::TweenOnScreen()
void GrooveRadar::GrooveRadarValueMap::TweenOffScreen()
{
BeginTweening( 0.6f );
SetTweenRotationZ( D3DX_PI*4 );
SetTweenRotationZ( PI*4 );
SetTweenZoom( 0 );
}
stepmania/src/RageBitmapTexture.cpp
+197 -31
View File
@@ -6,8 +6,8 @@
Desc: Holder for a static texture with metadata. Can load just about any image format.
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
Chris Danford
Glenn Maynard
Chris Danford
-----------------------------------------------------------------------------
*/
@@ -15,7 +15,7 @@
#include "RageUtil.h"
#include "RageLog.h"
#include "RageException.h"
#include "RageTextureManager.h"
#include "RageDisplay.h"
#include "SDL.h"
#include "SDL_image.h"
@@ -25,16 +25,59 @@
#include "SDL_dither.h"
#include "SDL_opengl.h"
#include "RageTimer.h"
/* Definitions for various texture formats. We'll probably want RGBA
* in OpenGL, not ARGB ... All of these are in local (little) endian;
* this may or may not need adjustment for OpenGL. */
const static unsigned int PixFmtMasks[][5] =
{
/* Err. D3D's texture formats are little-endian, so the order of
* colors (bytewise) is BGRA; D3DFMT_A8R8G8B8 is really BGRA (bytewise).
* D3DFMT_A4R4G4B4 is 0xGBAR; flip the bytes and it's sane (0xARGB).
*/
{ 0x00FF0000, /* B8G8R8A8 */
0x0000FF00,
0x000000FF,
0xFF000000, 32 },
{ 0x0F00, /* B4G4R4A4 */
0x00F0,
0x000F,
0xF000, 16 },
{ 0x7C00, /* B5G5R5A1 */
0x03E0,
0x001F,
0x8000, 16 },
// { 0xF800, /* B5G6R5 */ /* this format doesn't seem to be supported in OGL 1.0 */
// 0x07E0,
// 0x001F,
// 0x0000, 16 }
};
int PixFmtMaskNo(GLenum fmt)
{
switch(fmt) {
case GL_RGBA8: return 0;
case GL_RGBA4: return 1;
case GL_RGB5_A1: return 2;
// case D3DFMT_R5G6B5: return 3;
default: ASSERT(0); return 0;
}
}
//-----------------------------------------------------------------------------
// RageBitmapTexture constructor
//-----------------------------------------------------------------------------
RageBitmapTexture::RageBitmapTexture( const CString &sFilePath ) : RageTexture( sFilePath )
RageBitmapTexture::RageBitmapTexture( CString sFilePath, RageTexturePrefs prefs ) :
RageTexture( sFilePath, prefs )
{
// LOG->Trace( "RageBitmapTexture::RageBitmapTexture()" );
m_uGLTextureID = 0;
Load( sFilePath );
Create(); // sFilePath and prefs are saved by RageTexture()
}
RageBitmapTexture::~RageBitmapTexture()
@@ -43,35 +86,164 @@ RageBitmapTexture::~RageBitmapTexture()
glDeleteTextures(1, &m_uGLTextureID);
}
int power_of_two(int input)
void RageBitmapTexture::Reload( RageTexturePrefs prefs )
{
DISPLAY->SetTexture(0);
if(m_uGLTextureID)
{
glDeleteTextures(1, &m_uGLTextureID);
m_uGLTextureID = 0;
}
Create();
}
static int power_of_two(int input)
{
int value = 1;
while ( value < input ) value <<= 1;
return value;
}
void RageBitmapTexture::Load( const CString &sFilePath )
/*
* Each dwMaxSize, dwTextureColorDepth and iAlphaBits are maximums; we may
* use less. iAlphaBits must be 0, 1 or 4.
*
* XXX: change iAlphaBits == 4 to iAlphaBits == 8 to indicate "as much alpha
* as needed", since that's what it really is; still only use 4 in 16-bit textures.
*
* Dither forces dithering when loading 16-bit textures.
* Stretch forces the loaded image to fill the texture completely.
*/
void RageBitmapTexture::Create()
{
m_sFilePath = sFilePath; // save file path
// look in the file name for a format hints
m_sFilePath.MakeLower();
int iMaxSize = DISPLAY->GetMaxTextureSize();
SDL_Surface *img;
if( m_sFilePath.Find("no alpha") != -1 ) m_prefs.iAlphaBits = 0;
else if( m_sFilePath.Find("1 alpha") != -1 ) m_prefs.iAlphaBits = 1;
else if( m_sFilePath.Find("1alpha") != -1 ) m_prefs.iAlphaBits = 1;
else if( m_sFilePath.Find("0alpha") != -1 ) m_prefs.iAlphaBits = 0;
if( m_sFilePath.Find("dither") != -1 ) m_prefs.bDither = true;
/* Load the image into an SDL surface. */
img = IMG_Load(sFilePath);
if(!img)
throw RageException("Could not load graphic '%s'", sFilePath.GetString());
SDL_Surface *img = IMG_Load(m_sFilePath);
/* Save information about the source. Unless something else changes this
* later, the image inside the texture is the same size as the source. */
m_iImageWidth = m_iSourceWidth = img->w;
m_iImageHeight = m_iSourceHeight = img->h;
/* Figure out which texture format to use. */
GLenum fmtTexture;
if( m_prefs.iTextureColorDepth == 16 )
{
/* Bits of alpha in the source: */
int src_alpha_bits = 8 - img->format->Aloss;
/* No real alpha in paletted input. */
if( img->format->BytesPerPixel == 1 )
src_alpha_bits = 0;
/* Colorkeyed input effectively has at least one bit of alpha: */
if( img->flags & SDL_SRCCOLORKEY )
src_alpha_bits = max( 1, src_alpha_bits );
/* Don't use more than we were hinted to. */
src_alpha_bits = min( m_prefs.iAlphaBits, src_alpha_bits );
/* XXX Scan the image, and see if it actually uses its alpha channel/color key
* (if any). Reduce to 1 or 0 bits of alpha if possible. */
switch( src_alpha_bits ) {
case 0:
case 1:
fmtTexture = GL_RGB5_A1;
break;
default:
fmtTexture = GL_RGBA4;
break;
}
}
else if( m_prefs.iTextureColorDepth == 32 )
fmtTexture = GL_RGBA8;
else
throw RageException( "Invalid color depth: %d bits", m_prefs.iTextureColorDepth );
/* Cap the max texture size to the hardware max. */
m_prefs.iMaxSize = min( m_prefs.iMaxSize, DISPLAY->GetMaxTextureSize() );
/* Save information about the source. */
m_iSourceWidth = img->w;
m_iSourceHeight = img->h;
/* image size cannot exceed max size */
m_iImageWidth = min( m_iSourceWidth, m_prefs.iMaxSize );
m_iImageHeight = min( m_iSourceHeight, m_prefs.iMaxSize );
/* Texture dimensions need to be a power of two; jump to the next. */
m_iTextureWidth = power_of_two(img->w);
m_iTextureHeight = power_of_two(img->h);
m_iTextureWidth = power_of_two(m_iImageWidth);
m_iTextureHeight = power_of_two(m_iImageHeight);
ASSERT( m_iTextureWidth <= m_prefs.iMaxSize );
ASSERT( m_iTextureHeight <= m_prefs.iMaxSize );
/* If the source is larger than the texture, we have to scale it down; that's
* "stretching", I guess. */
if(m_iSourceWidth != m_iImageWidth || m_iSourceHeight > m_iImageHeight)
m_prefs.bStretch = true;
int target = PixFmtMaskNo(fmtTexture);
/* Dither only when the target is 16bpp, not when it's 32bpp. */
if( PixFmtMasks[target][4] /* XXX magic 4 */ == 4)
m_prefs.bDither = false;
if( m_prefs.bStretch )
{
/* resize currently only does RGBA8888 */
int mask = 0;
ConvertSDLSurface(img, img->w, img->h, PixFmtMasks[mask][4],
PixFmtMasks[mask][0], PixFmtMasks[mask][1], PixFmtMasks[mask][2], PixFmtMasks[mask][3]);
SDL_Surface *dst = zoomSurface(img, m_iImageWidth, m_iImageHeight );
SDL_FreeSurface(img);
img = dst;
// Commented out to see how things look without iterative filtering. -Chris
// while (m_iImageWidth != m_iTextureWidth || m_iImageHeight != m_iTextureHeight) {
// float xscale = float(m_iTextureWidth)/m_iImageWidth;
// float yscale = float(m_iTextureHeight)/m_iImageHeight;
//
// /* Our filter is a simple linear filter, so it can't scale to
// * less than .5 very well. If we need to go lower than .5, do
// * it iteratively. */
// xscale = max(xscale, .5f);
// yscale = max(yscale, .5f);
//
// SDL_Surface *dst = zoomSurface(img, xscale, yscale);
//
// SDL_FreeSurface(img);
// img = dst;
//
// /* The new image size is the full texture size. */
// m_iImageWidth = int(m_iImageWidth * xscale + .0001);
// m_iImageHeight = int(m_iImageHeight * yscale + .0001);
// }
}
if( m_prefs.bDither )
{
/* Dither down to the destination format. */
SDL_Surface *dst = SDL_CreateRGBSurfaceSane(SDL_SWSURFACE, img->w, img->h, PixFmtMasks[target][4],
PixFmtMasks[target][0], PixFmtMasks[target][1], PixFmtMasks[target][2], PixFmtMasks[target][3]);
SM_SDL_OrderedDither(img, dst);
SDL_FreeSurface(img);
img = dst;
}
/* Convert the data to the destination format. Hmm. We could just
* convert the format, leaving the resolution alone (simplifying
@@ -91,23 +263,17 @@ void RageBitmapTexture::Load( const CString &sFilePath )
glPixelStorei(GL_UNPACK_ROW_LENGTH, img->pitch / img->format->BytesPerPixel);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, img->w, img->h, 0, GL_RGBA,
glTexImage2D(GL_TEXTURE_2D, 0, fmtTexture, img->w, img->h, 0, GL_RGBA,
GL_UNSIGNED_BYTE, img->pixels);
glFlush();
SDL_FreeSurface(img);
CreateFrameRects();
// LOG->Trace( "RageBitmapTexture: Loaded '%s' (%ux%u) from disk. bStretch = %d, source %d,%d; image %d,%d.",
// m_sFilePath.GetString(), GetTextureWidth(), GetTextureHeight(),
// bStretch, m_iSourceWidth, m_iSourceHeight,
// m_iImageWidth, m_iImageHeight);
}
void RageBitmapTexture::Reload()
{
DISPLAY->SetTexture(0);
if(m_uGLTextureID) {
glDeleteTextures(1, &m_uGLTextureID);
m_uGLTextureID = 0;
}
Load( m_sFilePath );
}
stepmania/src/RageBitmapTexture.h
+8 -11
View File
@@ -1,4 +1,6 @@
#pragma once
#ifndef RAGEBITMAPTEXTURE_H
#define RAGEBITMAPTEXTURE_H
/*
-----------------------------------------------------------------------------
Class: RageBitmapTexture
@@ -10,29 +12,24 @@
-----------------------------------------------------------------------------
*/
#include "RageDisplay.h"
#include "RageTexture.h"
#include <d3dx8.h>
#include <assert.h>
//-----------------------------------------------------------------------------
// RageBitmapTexture Class Declarations
//-----------------------------------------------------------------------------
class RageBitmapTexture : public RageTexture
{
public:
RageBitmapTexture( const CString &sFilePath );
RageBitmapTexture( CString sFilePath, RageTexturePrefs prefs );
virtual ~RageBitmapTexture();
/* only called by RageTextureManager::InvalidateTextures */
virtual void Invalidate() { m_uGLTextureID = 0; }
virtual void Reload( RageTexturePrefs prefs );
protected:
virtual void Load( const CString &sFilePath );
virtual void Reload();
void Create(); // called by constructor and Reload
virtual unsigned int GetGLTextureID() { return m_uGLTextureID; }
unsigned int m_uGLTextureID;
CString m_sFilePath;
};
#endif
stepmania/src/RageTexture.cpp
+2 -1
View File
@@ -22,11 +22,12 @@
//-----------------------------------------------------------------------------
// RageTexture constructor
//-----------------------------------------------------------------------------
RageTexture::RageTexture( const CString &sFilePath )
RageTexture::RageTexture( CString sFilePath, RageTexturePrefs prefs )
{
// LOG->Trace( "RageTexture::RageTexture()" );
m_sFilePath = sFilePath;
m_prefs = prefs;
m_iRefCount = 1;
m_iSourceWidth = m_iSourceHeight = 0;
stepmania/src/RageTexture.h
+27 -6
View File
@@ -17,16 +17,39 @@
const int MAX_TEXTURE_FRAMES = 256;
struct RageTexturePrefs
{
bool bForceReload;
int iMaxSize;
int iTextureColorDepth;
int iMipMaps;
int iAlphaBits;
bool bDither;
bool bStretch;
RageTexturePrefs()
{
bForceReload = false;
iMaxSize = 2048;
iTextureColorDepth = 16;
iMipMaps = 4;
iAlphaBits = 4;
bDither = false;
bStretch = false;
}
};
//-----------------------------------------------------------------------------
// RageTexture Class Declarations
//-----------------------------------------------------------------------------
class RageTexture
{
public:
RageTexture( const CString &sFilePath );
RageTexture( CString sFilePath, RageTexturePrefs prefs );
virtual ~RageTexture() = 0;
virtual void Reload() = 0;
virtual void Reload( RageTexturePrefs prefs ) = 0;
virtual void Invalidate() { } /* only called by RageTextureManager::InvalidateTextures */
virtual unsigned int GetGLTextureID() = 0; // accessed by RageDisplay
// movie texture/animated texture stuff
virtual void Play() {}
@@ -61,9 +84,6 @@ public:
int m_iRefCount;
int m_iTimeOfLastUnload;
/* only called by RageTextureManager::InvalidateTextures */
virtual void Invalidate() { }
virtual unsigned int GetGLTextureID() = 0; // accessed by RageDisplay
protected:
@@ -71,6 +91,7 @@ protected:
virtual void GetFrameDimensionsFromFileName( CString sPath, int* puFramesWide, int* puFramesHigh ) const;
CString m_sFilePath;
RageTexturePrefs m_prefs;
int m_iSourceWidth, m_iSourceHeight; // dimensions of the original image loaded from disk
int m_iTextureWidth, m_iTextureHeight; // dimensions of the texture in memory
stepmania/src/RageTextureManager.cpp
+2 -2
View File
@@ -77,7 +77,7 @@ RageTexture* RageTextureManager::LoadTexture( CString sTexturePath )
// if( sExt == "avi" || sExt == "mpg" || sExt == "mpeg" )
// pTexture = new RageMovieTexture( sTexturePath );
// else
pTexture = new RageBitmapTexture( sTexturePath );
pTexture = new RageBitmapTexture( sTexturePath, RageTexturePrefs() );
LOG->Trace( "RageTextureManager: Finished loading '%s'.", sTexturePath.GetString() );
@@ -179,7 +179,7 @@ void RageTextureManager::ReloadAll()
{
RageTexture* pTexture = i->second;
pTexture->Reload(); // this is not entirely correct. Hints are lost! XXX
pTexture->Reload( RageTexturePrefs() ); // this is not entirely correct. Hints are lost! XXX
}
}
stepmania/src/SDL_rotozoom.cpp
+3 -23
View File
@@ -141,34 +141,14 @@ void zoomSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst)
*/
void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight)
{
/*
* Sanity check zoom factors
*/
if (zoomx < VALUE_LIMIT) zoomx = VALUE_LIMIT;
if (zoomy < VALUE_LIMIT) zoomy = VALUE_LIMIT;
/* Calculate target size */
*dstwidth = (int) ((double) width * zoomx);
*dstheight = (int) ((double) height * zoomy);
if (*dstwidth < 1) *dstwidth = 1;
if (*dstheight < 1) *dstheight = 1;
}
SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy)
SDL_Surface *zoomSurface(SDL_Surface * src, int dstwidth, int dstheight)
{
SDL_Surface *rz_dst;
int dstwidth, dstheight;
/*
* Sanity check
*/
/* Sanity check */
if (src == NULL)
return (NULL);
/* Get size if target */
zoomSurfaceSize(src->w, src->h, zoomx, zoomy, &dstwidth, &dstheight);
return (NULL);
/* Alloc space to completely contain the zoomed surface */
/* Target surface is 32bit with source RGBA/ABGR ordering */
stepmania/src/SDL_rotozoom.h
+1 -3
View File
@@ -22,9 +22,7 @@
*/
SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy);
SDL_Surface *zoomSurface(SDL_Surface * src, int dstwidth, int dstheight);
/* Returns the size of the target surface for a zoomSurface() call */
void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight);
#endif
stepmania/src/Sprite.cpp
+4 -14
View File
@@ -43,13 +43,6 @@ Sprite::~Sprite()
}
bool Sprite::LoadFromTexture( CString sTexturePath, bool bForceReload, int iMipMaps, int iAlphaBits, bool bDither, bool bStretch )
{
LOG->Trace( ssprintf("Sprite::LoadFromTexture(%s)", sTexturePath.GetString()) );
//Init();
return LoadTexture( sTexturePath, bForceReload, iMipMaps, iAlphaBits, bDither, bStretch );
}
// Sprite file has the format:
//
@@ -59,7 +52,7 @@ bool Sprite::LoadFromTexture( CString sTexturePath, bool bForceReload, int iMipM
// Delay0000=1.0
// Frame0001=3
// Delay0000=2.0
bool Sprite::LoadFromSpriteFile( CString sSpritePath, bool bForceReload, int iMipMaps, int iAlphaBits, bool bDither, bool bStretch )
bool Sprite::LoadFromSpriteFile( CString sSpritePath, RageTexturePrefs prefs )
{
LOG->Trace( ssprintf("Sprite::LoadFromSpriteFile(%s)", sSpritePath.GetString()) );
@@ -93,15 +86,12 @@ bool Sprite::LoadFromSpriteFile( CString sSpritePath, bool bForceReload, int iMi
throw RageException( "The sprite file '%s' points to a texture '%s' which doesn't exist.", m_sSpritePath.GetString(), sTexturePath.GetString() );
// Load the texture
if( !LoadTexture( sTexturePath ) )
return FALSE;
LoadFromTexture( sTexturePath, prefs );
// Read in frames and delays from the sprite file,
// overwriting the states that LoadFromTexture created.
for( UINT i=0; i<MAX_SPRITE_STATES; i++ )
for( int i=0; i<MAX_SPRITE_STATES; i++ )
{
CString sFrameKey = ssprintf( "Frame%04d", i );
CString sDelayKey = ssprintf( "Delay%04d", i );
@@ -141,7 +131,7 @@ void Sprite::UnloadTexture()
m_sTexturePath = "";
}
bool Sprite::LoadTexture( CString sTexturePath, bool bForceReload, int iMipMaps, int iAlphaBits, bool bDither, bool bStretch )
bool Sprite::LoadFromTexture( CString sTexturePath, RageTexturePrefs prefs )
{
UnloadTexture();
stepmania/src/Sprite.h
+6 -9
View File
@@ -27,13 +27,14 @@ public:
Sprite();
virtual ~Sprite();
virtual bool Load( CString sFilePath, bool bForceReload = false, int iMipMaps = 4, int iAlphaBits = 4, bool bDither = false, bool bStretch = false )
virtual bool Load( CString sFilePath ) { return Load( sFilePath, RageTexturePrefs() ); }
virtual bool Load( CString sFilePath, RageTexturePrefs prefs )
{
ASSERT( sFilePath != "" );
if( sFilePath.Right(7) == ".sprite" )
return LoadFromSpriteFile( sFilePath, bForceReload, iMipMaps, iAlphaBits, bDither, bStretch );
return LoadFromSpriteFile( sFilePath, prefs );
else
return LoadFromTexture( sFilePath, bForceReload, iMipMaps, iAlphaBits, bDither, bStretch );
return LoadFromTexture( sFilePath, prefs );
};
void UnloadTexture();
RageTexture* GetTexture() { return m_pTexture; };
@@ -58,12 +59,8 @@ public:
void StopUsingCustomCoords();
protected:
virtual bool LoadFromTexture( CString sTexturePath, bool bForceReload = false, int iMipMaps = 4, int iAlphaBits = 4, bool bDither = false, bool bStretch = false );
virtual bool LoadFromSpriteFile( CString sSpritePath, bool bForceReload = false, int iMipMaps = 4, int iAlphaBits = 4, bool bDither = false, bool bStretch = false );
virtual bool LoadTexture( CString sTexture, bool bForceReload = false, int iMipMaps = 4, int iAlphaBits = 4, bool bDither = false, bool bStretch = false );
virtual bool LoadFromTexture( CString sTexturePath, RageTexturePrefs prefs );
virtual bool LoadFromSpriteFile( CString sSpritePath, RageTexturePrefs prefs );
CString m_sSpritePath;