ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

First pass at fixing OpenGL mode. There are still several issues with 

the UI stuff, but at least emulation mode is now working.  But for
some strange reason, starting a ROM from the commandline gives a blank
screen, while it works fine from the ROM launcher.


git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@1549 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba
This commit is contained in:
stephena 2008-08-05 12:54:47 +00:00
parent 6ba918320a
commit dbc36a32e2
2 changed files with 222 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

387
stella/src/common/FrameBufferGL.cxx
View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: FrameBufferGL.cxx,v 1.105 2008-08-04 11:56:11 stephena Exp $ // $Id: FrameBufferGL.cxx,v 1.106 2008-08-05 12:54:47 stephena Exp $
//============================================================================ //============================================================================
#ifdef DISPLAY_OPENGL #ifdef DISPLAY_OPENGL
@ -72,7 +72,7 @@ static void (APIENTRY* p_glTexParameteri)( GLenum, GLenum, GLint );
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FrameBufferGL::FrameBufferGL(OSystem* osystem) FrameBufferGL::FrameBufferGL(OSystem* osystem)
: FrameBuffer(osystem), : FrameBuffer(osystem),
myTexture(NULL), myTiaSurface(NULL),
myHaveTexRectEXT(false), myHaveTexRectEXT(false),
myFilterParamName("GL_NEAREST"), myFilterParamName("GL_NEAREST"),
myWidthScaleFactor(1.0), myWidthScaleFactor(1.0),
@ -84,10 +84,6 @@ FrameBufferGL::FrameBufferGL(OSystem* osystem)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FrameBufferGL::~FrameBufferGL() FrameBufferGL::~FrameBufferGL()
{ {
if(myTexture)
SDL_FreeSurface(myTexture);
p_glDeleteTextures(1, &myBuffer.texture);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -236,24 +232,18 @@ string FrameBufferGL::about() const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool FrameBufferGL::setVidMode(VideoMode& mode) bool FrameBufferGL::setVidMode(VideoMode& mode)
{ {
return false;
#if 0
bool inUIMode = bool inUIMode =
myOSystem->eventHandler().state() == EventHandler::S_LAUNCHER || myOSystem->eventHandler().state() == EventHandler::S_LAUNCHER ||
myOSystem->eventHandler().state() == EventHandler::S_DEBUGGER; myOSystem->eventHandler().state() == EventHandler::S_DEBUGGER;
myScreenDim.x = myScreenDim.y = 0; // Grab the initial width and height before it's updated below
myScreenDim.w = mode.screen_w; uInt32 baseWidth = mode.image_w / mode.gfxmode.zoom;
myScreenDim.h = mode.screen_h; uInt32 baseHeight = mode.image_h / mode.gfxmode.zoom;
myImageDim.x = mode.image_x;
myImageDim.y = mode.image_y;
myImageDim.w = mode.image_w;
myImageDim.h = mode.image_h;
// FIXME - look at actual videomode type
// Normally, we just scale to the given zoom level // Normally, we just scale to the given zoom level
myWidthScaleFactor = (float) mode.zoom; myWidthScaleFactor = (float) mode.gfxmode.zoom;
myHeightScaleFactor = (float) mode.zoom; myHeightScaleFactor = (float) mode.gfxmode.zoom;
// Activate aspect ratio correction in TIA mode // Activate aspect ratio correction in TIA mode
int iaspect = myOSystem->settings().getInt("gl_aspect"); int iaspect = myOSystem->settings().getInt("gl_aspect");
@ -261,13 +251,13 @@ return false;
{ {
float aspectFactor = float(iaspect) / 100.0; float aspectFactor = float(iaspect) / 100.0;
myWidthScaleFactor *= aspectFactor; myWidthScaleFactor *= aspectFactor;
myImageDim.w = (uInt16)(float(myImageDim.w) * aspectFactor); mode.image_w = (uInt16)(float(mode.image_w) * aspectFactor);
} }
// Activate stretching if its been requested in fullscreen mode // Activate stretching if its been requested in fullscreen mode
float stretchFactor = 1.0; float stretchFactor = 1.0;
if(fullScreen() && (myImageDim.w < myScreenDim.w) && if(fullScreen() && (mode.image_w < mode.screen_w) &&
(myImageDim.h < myScreenDim.h)) (mode.image_h < mode.screen_h))
{ {
const string& gl_fsmax = myOSystem->settings().getString("gl_fsmax"); const string& gl_fsmax = myOSystem->settings().getString("gl_fsmax");
@ -276,24 +266,24 @@ return false;
(inUIMode && gl_fsmax == "ui") || (inUIMode && gl_fsmax == "ui") ||
(!inUIMode && gl_fsmax == "tia")) (!inUIMode && gl_fsmax == "tia"))
{ {
float scaleX = float(myImageDim.w) / myScreenDim.w; float scaleX = float(mode.image_w) / mode.screen_w;
float scaleY = float(myImageDim.h) / myScreenDim.h; float scaleY = float(mode.image_h) / mode.screen_h;
if(scaleX > scaleY) if(scaleX > scaleY)
stretchFactor = float(myScreenDim.w) / myImageDim.w; stretchFactor = float(mode.screen_w) / mode.image_w;
else else
stretchFactor = float(myScreenDim.h) / myImageDim.h; stretchFactor = float(mode.screen_h) / mode.image_h;
} }
} }
myWidthScaleFactor *= stretchFactor; myWidthScaleFactor *= stretchFactor;
myHeightScaleFactor *= stretchFactor; myHeightScaleFactor *= stretchFactor;
// Now re-calculate the dimensions // Now re-calculate the dimensions
myImageDim.w = (Uint16) (stretchFactor * myImageDim.w); mode.image_w = (Uint16) (stretchFactor * mode.image_w);
myImageDim.h = (Uint16) (stretchFactor * myImageDim.h); mode.image_h = (Uint16) (stretchFactor * mode.image_h);
if(!fullScreen()) myScreenDim.w = myImageDim.w; if(!fullScreen()) mode.screen_w = mode.image_w;
myImageDim.x = (myScreenDim.w - myImageDim.w) / 2; mode.image_x = (mode.screen_w - mode.image_w) / 2;
myImageDim.y = (myScreenDim.h - myImageDim.h) / 2; mode.image_y = (mode.screen_h - mode.image_h) / 2;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, myRGB[0] ); SDL_GL_SetAttribute( SDL_GL_RED_SIZE, myRGB[0] );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, myRGB[1] ); SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, myRGB[1] );
@ -308,7 +298,7 @@ return false;
SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, vsync ); SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, vsync );
// Create screen containing GL context // Create screen containing GL context
myScreen = SDL_SetVideoMode(myScreenDim.w, myScreenDim.h, 0, mySDLFlags); myScreen = SDL_SetVideoMode(mode.screen_w, mode.screen_h, 0, mySDLFlags);
if(myScreen == NULL) if(myScreen == NULL)
{ {
cerr << "ERROR: Unable to open SDL window: " << SDL_GetError() << endl; cerr << "ERROR: Unable to open SDL window: " << SDL_GetError() << endl;
@ -331,7 +321,7 @@ return false;
myHaveTexRectEXT = false; myHaveTexRectEXT = false;
// Initialize GL display // Initialize GL display
p_glViewport(myImageDim.x, myImageDim.y, myImageDim.w, myImageDim.h); p_glViewport(mode.image_x, mode.image_y, mode.image_w, mode.image_h);
p_glShadeModel(GL_FLAT); p_glShadeModel(GL_FLAT);
p_glDisable(GL_CULL_FACE); p_glDisable(GL_CULL_FACE);
p_glDisable(GL_DEPTH_TEST); p_glDisable(GL_DEPTH_TEST);
@ -341,14 +331,21 @@ return false;
p_glMatrixMode(GL_PROJECTION); p_glMatrixMode(GL_PROJECTION);
p_glLoadIdentity(); p_glLoadIdentity();
p_glOrtho(0.0, myImageDim.w, myImageDim.h, 0.0, 0.0, 1.0); p_glOrtho(0.0, mode.image_w, mode.image_h, 0.0, 0.0, 1.0);
p_glMatrixMode(GL_MODELVIEW); p_glMatrixMode(GL_MODELVIEW);
p_glLoadIdentity(); p_glLoadIdentity();
// Allocate GL textures // Allocate GL textures
createTextures(); cerr << "dimensions: " << endl
<< " basew = " << baseWidth << endl
<< " baseh = " << baseHeight << endl
<< " imagew = " << mode.image_w << endl
<< " imageh = " << mode.image_h << endl
<< endl;
p_glEnable(myBuffer.target); delete myTiaSurface;
myTiaSurface = new FBSurfaceGL(*this, baseWidth, baseHeight,
mode.image_w, mode.image_h);
// Make sure any old parts of the screen are erased // Make sure any old parts of the screen are erased
p_glClear(GL_COLOR_BUFFER_BIT); p_glClear(GL_COLOR_BUFFER_BIT);
@ -356,7 +353,6 @@ return false;
p_glClear(GL_COLOR_BUFFER_BIT); p_glClear(GL_COLOR_BUFFER_BIT);
return true; return true;
#endif
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -369,7 +365,8 @@ void FrameBufferGL::drawMediaSource()
uInt8* previousFrame = mediasrc.previousFrameBuffer(); uInt8* previousFrame = mediasrc.previousFrameBuffer();
uInt32 width = mediasrc.width(); uInt32 width = mediasrc.width();
uInt32 height = mediasrc.height(); uInt32 height = mediasrc.height();
uInt16* buffer = (uInt16*) myTexture->pixels; uInt32 pitch = myTiaSurface->pitch();
uInt16* buffer = (uInt16*) myTiaSurface->pixels();
// TODO - is this fast enough? // TODO - is this fast enough?
if(!myUsePhosphor) if(!myUsePhosphor)
@ -397,7 +394,7 @@ void FrameBufferGL::drawMediaSource()
pos += 2; pos += 2;
} }
bufofsY += width; bufofsY += width;
screenofsY += myBuffer.pitch; screenofsY += pitch;
} }
} }
else else
@ -421,9 +418,13 @@ void FrameBufferGL::drawMediaSource()
buffer[pos++] = (uInt16) myAvgPalette[v][w]; buffer[pos++] = (uInt16) myAvgPalette[v][w];
} }
bufofsY += width; bufofsY += width;
screenofsY += myBuffer.pitch; screenofsY += pitch;
} }
} }
// And blit the surface
myTiaSurface->addDirtyRect(0, 0, 0, 0);
myTiaSurface->update();
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -431,27 +432,8 @@ void FrameBufferGL::postFrameUpdate()
{ {
if(myDirtyFlag) if(myDirtyFlag)
{ {
// Texturemap complete texture to surface so we have free scaling
// and antialiasing
// FIXME uInt32 w = myImageDim.w, h = myImageDim.h;
uInt32 w = 0, h = 0;
p_glTexSubImage2D(myBuffer.target, 0, 0, 0,
myBuffer.texture_width, myBuffer.texture_height,
myBuffer.format, myBuffer.type, myBuffer.pixels);
p_glBegin(GL_QUADS);
p_glTexCoord2f(myBuffer.tex_coord[0], myBuffer.tex_coord[1]); p_glVertex2i(0, 0);
p_glTexCoord2f(myBuffer.tex_coord[2], myBuffer.tex_coord[1]); p_glVertex2i(w, 0);
p_glTexCoord2f(myBuffer.tex_coord[2], myBuffer.tex_coord[3]); p_glVertex2i(w, h);
p_glTexCoord2f(myBuffer.tex_coord[0], myBuffer.tex_coord[3]); p_glVertex2i(0, h);
p_glEnd();
// Overlay UI dialog boxes
// Now show all changes made to the texture // Now show all changes made to the texture
SDL_GL_SwapBuffers(); SDL_GL_SwapBuffers();
myDirtyFlag = false; myDirtyFlag = false;
} }
} }
@ -465,9 +447,16 @@ void FrameBufferGL::enablePhosphor(bool enable, int blend)
myRedrawEntireFrame = true; myRedrawEntireFrame = true;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Uint32 FrameBufferGL::mapRGB(Uint8 r, Uint8 g, Uint8 b) const
{
return myTiaSurface->mapRGB(r, g, b);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FrameBufferGL::toggleFilter() void FrameBufferGL::toggleFilter()
{ {
/*
if(myBuffer.filter == GL_NEAREST) if(myBuffer.filter == GL_NEAREST)
{ {
myBuffer.filter = GL_LINEAR; myBuffer.filter = GL_LINEAR;
@ -489,29 +478,17 @@ void FrameBufferGL::toggleFilter()
// The filtering has changed, so redraw the entire screen // The filtering has changed, so redraw the entire screen
myRedrawEntireFrame = true; myRedrawEntireFrame = true;
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FBSurface* FrameBufferGL::createSurface(int w, int h, bool isBase) const FBSurface* FrameBufferGL::createSurface(int w, int h, bool isBase) const
{ {
return 0; // Ignore 'isBase' argument; all GL surfaces are separate
#if 0 // Also, since this method will only be called for use in external
SDL_PixelFormat* fmt = myTexture->format; // dialogs which cannot be scaled, the base and scaled parameters
SDL_Surface* data = // are equal
SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 16, return new FBSurfaceGL((FrameBufferGL&)*this, w, h, w, h);
fmt->Rmask, fmt->Gmask, fmt->Bmask, fmt->Amask);
return data ? new GUI::Surface(width, height, data) : NULL;
/*
SDL_Surface* surface = isBase ? myScreen :
SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, myFormat->BitsPerPixel,
myFormat->Rmask, myFormat->Gmask, myFormat->Bmask,
myFormat->Amask);
return new FBSurfaceSoft(*this, surface, w, h, isBase);
*/
#endif
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -532,59 +509,148 @@ void FrameBufferGL::scanline(uInt32 row, uInt8* data) const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FBSurfaceGL::FBSurfaceGL(const FrameBufferGL& buffer, SDL_Surface* surface, FBSurfaceGL::FBSurfaceGL(FrameBufferGL& buffer,
uInt32 w, uInt32 h, bool isBase) uInt32 baseWidth, uInt32 baseHeight,
: myFB(buffer) uInt32 scaleWidth, uInt32 scaleHeight)
: myFB(buffer),
myWidth(scaleWidth),
myHeight(scaleHeight)
{ {
// Fill buffer struct with valid data
// This changes depending on the texturing used
myTexCoord[0] = 0.0f;
myTexCoord[1] = 0.0f;
if(1)// FIXME myHaveTexRectEXT)
{
myTexWidth = baseWidth;
myTexHeight = baseHeight;
myTexTarget = GL_TEXTURE_RECTANGLE_ARB;
myTexCoord[2] = (GLfloat) myTexWidth;
myTexCoord[3] = (GLfloat) myTexHeight;
}
else
{
myTexWidth = power_of_two(baseWidth);
myTexHeight = power_of_two(baseHeight);
myTexTarget = GL_TEXTURE_2D;
myTexCoord[2] = (GLfloat) baseWidth / myTexWidth;
myTexCoord[3] = (GLfloat) baseHeight / myTexHeight;
}
// Create a texture that best suits the current display depth and system
// This code needs to be Apple-specific, otherwise performance is
// terrible on a Mac Mini
#if defined(MAC_OSX)
myTexture = SDL_CreateRGBSurface(SDL_SWSURFACE,
myTexWidth, myTexHeight, 16,
0x00007c00, 0x000003e0, 0x0000001f, 0x00000000);
#else
myTexture = SDL_CreateRGBSurface(SDL_SWSURFACE,
myTexWidth, myTexHeight, 16,
0x0000f800, 0x000007e0, 0x0000001f, 0x00000000);
#endif
switch(myTexture->format->BytesPerPixel)
{
case 2: // 16-bit
myPitch = myTexture->pitch/2;
break;
case 3: // 24-bit
myPitch = myTexture->pitch;
break;
case 4: // 32-bit
myPitch = myTexture->pitch/4;
break;
default:
break;
}
/*
// Create an OpenGL texture from the SDL texture
const string& filter = myOSystem->settings().getString("gl_filter");
if(filter == "linear")
{
myBuffer.filter = GL_LINEAR;
myFilterParamName = "GL_LINEAR";
}
else if(filter == "nearest")
{
myBuffer.filter = GL_NEAREST;
myFilterParamName = "GL_NEAREST";
}
*/
p_glGenTextures(1, &myTexID);
p_glBindTexture(myTexTarget, myTexID);
p_glTexParameteri(myTexTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
p_glTexParameteri(myTexTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// p_glTexParameteri(myTexTarget, GL_TEXTURE_MIN_FILTER, myBuffer.filter);
// p_glTexParameteri(myTexTarget, GL_TEXTURE_MAG_FILTER, myBuffer.filter);
p_glTexParameteri(myTexTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
p_glTexParameteri(myTexTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// Finally, create the texture in the most optimal format
GLenum tex_intformat;
#if defined (MAC_OSX)
tex_intformat = GL_RGB5;
myTexFormat = GL_BGRA;
myTexType = GL_UNSIGNED_SHORT_1_5_5_5_REV;
#else
tex_intformat = GL_RGB;
myTexFormat = GL_RGB;
myTexType = GL_UNSIGNED_SHORT_5_6_5;
#endif
p_glTexImage2D(myTexTarget, 0, tex_intformat,
myTexWidth, myTexHeight, 0,
myTexFormat, myTexType, myTexture->pixels);
p_glEnable(myTexTarget);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FBSurfaceGL::~FBSurfaceGL() FBSurfaceGL::~FBSurfaceGL()
{ {
if(myTexture)
SDL_FreeSurface(myTexture);
p_glDeleteTextures(1, &myTexID);
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::hLine(uInt32 x, uInt32 y, uInt32 x2, int color) void FBSurfaceGL::hLine(uInt32 x, uInt32 y, uInt32 x2, int color)
{ {
/* uInt16* buffer = (uInt16*) myTexture->pixels + y * myPitch + x;
uInt16* buffer = (uInt16*) myTexture->pixels + y * myBuffer.pitch + x;
while(x++ <= x2) while(x++ <= x2)
*buffer++ = (uInt16) myDefPalette[color]; *buffer++ = (uInt16) myFB.myDefPalette[color];
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::vLine(uInt32 x, uInt32 y, uInt32 y2, int color) void FBSurfaceGL::vLine(uInt32 x, uInt32 y, uInt32 y2, int color)
{ {
/* uInt16* buffer = (uInt16*) myTexture->pixels + y * myPitch + x;
uInt16* buffer = (uInt16*) myTexture->pixels + y * myBuffer.pitch + x;
while(y++ <= y2) while(y++ <= y2)
{ {
*buffer = (uInt16) myDefPalette[color]; *buffer = (uInt16) myFB.myDefPalette[color];
buffer += myBuffer.pitch; buffer += myPitch;
} }
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::fillRect(uInt32 x, uInt32 y, uInt32 w, uInt32 h, int color) void FBSurfaceGL::fillRect(uInt32 x, uInt32 y, uInt32 w, uInt32 h, int color)
{ {
/*
// Fill the rectangle // Fill the rectangle
SDL_Rect tmp; SDL_Rect tmp;
tmp.x = x; tmp.x = x;
tmp.y = y; tmp.y = y;
tmp.w = w; tmp.w = w;
tmp.h = h; tmp.h = h;
SDL_FillRect(myTexture, &tmp, myDefPalette[color]); SDL_FillRect(myTexture, &tmp, myFB.myDefPalette[color]);
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::drawChar(const GUI::Font* font, uInt8 chr, void FBSurfaceGL::drawChar(const GUI::Font* font, uInt8 chr,
uInt32 tx, uInt32 ty, int color) uInt32 tx, uInt32 ty, int color)
{ {
/*
const FontDesc& desc = font->desc(); const FontDesc& desc = font->desc();
// If this character is not included in the font, use the default char. // If this character is not included in the font, use the default char.
@ -599,7 +665,7 @@ void FBSurfaceGL::drawChar(const GUI::Font* font, uInt8 chr,
chr -= desc.firstchar; chr -= desc.firstchar;
const uInt32* tmp = desc.bits + (desc.offset ? desc.offset[chr] : (chr * h)); const uInt32* tmp = desc.bits + (desc.offset ? desc.offset[chr] : (chr * h));
uInt16* buffer = (uInt16*) myTexture->pixels + ty * myBuffer.pitch + tx; uInt16* buffer = (uInt16*) myTexture->pixels + ty * myPitch + tx;
for(int y = 0; y < h; ++y) for(int y = 0; y < h; ++y)
{ {
const uInt32 ptr = *tmp++; const uInt32 ptr = *tmp++;
@ -608,36 +674,33 @@ void FBSurfaceGL::drawChar(const GUI::Font* font, uInt8 chr,
uInt32 mask = 0x80000000; uInt32 mask = 0x80000000;
for(int x = 0; x < w; ++x, mask >>= 1) for(int x = 0; x < w; ++x, mask >>= 1)
if(ptr & mask) if(ptr & mask)
buffer[x] = (uInt16) myDefPalette[color]; buffer[x] = (uInt16) myFB.myDefPalette[color];
} }
buffer += myBuffer.pitch; buffer += myPitch;
} }
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::drawBitmap(uInt32* bitmap, Int32 tx, Int32 ty, void FBSurfaceGL::drawBitmap(uInt32* bitmap, Int32 tx, Int32 ty,
int color, Int32 h) int color, Int32 h)
{ {
/* uInt16* buffer = (uInt16*) myTexture->pixels + ty * myPitch + tx;
uInt16* buffer = (uInt16*) myTexture->pixels + ty * myBuffer.pitch + tx;
for(int y = 0; y < h; ++y) for(int y = 0; y < h; ++y)
{ {
uInt32 mask = 0xF0000000; uInt32 mask = 0xF0000000;
for(int x = 0; x < 8; ++x, mask >>= 4) for(int x = 0; x < 8; ++x, mask >>= 4)
if(bitmap[y] & mask) if(bitmap[y] & mask)
buffer[x] = (uInt16) myDefPalette[color]; buffer[x] = (uInt16) myFB.myDefPalette[color];
buffer += myBuffer.pitch; buffer += myPitch;
} }
*/
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::addDirtyRect(uInt32 x, uInt32 y, uInt32 w, uInt32 h) void FBSurfaceGL::addDirtyRect(uInt32 x, uInt32 y, uInt32 w, uInt32 h)
{ {
// myDirtyFlag = true; mySurfaceIsDirty = true;
} }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -689,112 +752,24 @@ void FBSurfaceGL::translateCoords(Int32& x, Int32& y) const
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void FBSurfaceGL::update() void FBSurfaceGL::update()
{ {
} if(mySurfaceIsDirty)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
bool FrameBufferGL::createTextures()
{
if(myTexture)
{ {
p_glClear(GL_COLOR_BUFFER_BIT); // Texturemap complete texture to surface so we have free scaling
SDL_GL_SwapBuffers(); // and antialiasing
p_glClear(GL_COLOR_BUFFER_BIT); p_glTexSubImage2D(myTexTarget, 0, 0, 0, myTexWidth, myTexHeight,
SDL_FreeSurface(myTexture); myTexFormat, myTexType, myTexture->pixels);
p_glBegin(GL_QUADS);
p_glTexCoord2f(myTexCoord[0], myTexCoord[1]); p_glVertex2i(0, 0);
p_glTexCoord2f(myTexCoord[2], myTexCoord[1]); p_glVertex2i(myWidth, 0);
p_glTexCoord2f(myTexCoord[2], myTexCoord[3]); p_glVertex2i(myWidth, myHeight);
p_glTexCoord2f(myTexCoord[0], myTexCoord[3]); p_glVertex2i(0, myHeight);
p_glEnd();
mySurfaceIsDirty = false;
// Let postFrameUpdate() know that a change has been made
myFB.myDirtyFlag = true;
} }
if(myBuffer.texture) p_glDeleteTextures(1, &myBuffer.texture);
memset(&myBuffer, 0, sizeof(glBufferType));
myBuffer.filter = GL_NEAREST;
// Fill buffer struct with valid data
// This changes depending on the texturing used
myBuffer.width = 0;//FIXME myBaseDim.w;
myBuffer.height = 0;//FIXME myBaseDim.h;
myBuffer.tex_coord[0] = 0.0f;
myBuffer.tex_coord[1] = 0.0f;
if(myHaveTexRectEXT)
{
myBuffer.texture_width = myBuffer.width;
myBuffer.texture_height = myBuffer.height;
myBuffer.target = GL_TEXTURE_RECTANGLE_ARB;
myBuffer.tex_coord[2] = (GLfloat) myBuffer.texture_width;
myBuffer.tex_coord[3] = (GLfloat) myBuffer.texture_height;
}
else
{
myBuffer.texture_width = power_of_two(myBuffer.width);
myBuffer.texture_height = power_of_two(myBuffer.height);
myBuffer.target = GL_TEXTURE_2D;
myBuffer.tex_coord[2] = (GLfloat) myBuffer.width / myBuffer.texture_width;
myBuffer.tex_coord[3] = (GLfloat) myBuffer.height / myBuffer.texture_height;
}
// Create a texture that best suits the current display depth and system
// This code needs to be Apple-specific, otherwise performance is
// terrible on a Mac Mini
#if defined(MAC_OSX)
myTexture = SDL_CreateRGBSurface(SDL_SWSURFACE,
myBuffer.texture_width, myBuffer.texture_height, 16,
0x00007c00, 0x000003e0, 0x0000001f, 0x00000000);
#else
myTexture = SDL_CreateRGBSurface(SDL_SWSURFACE,
myBuffer.texture_width, myBuffer.texture_height, 16,
0x0000f800, 0x000007e0, 0x0000001f, 0x00000000);
#endif
if(myTexture == NULL)
return false;
myBuffer.pixels = myTexture->pixels;
switch(myTexture->format->BytesPerPixel)
{
case 2: // 16-bit
myBuffer.pitch = myTexture->pitch/2;
break;
case 3: // 24-bit
myBuffer.pitch = myTexture->pitch;
break;
case 4: // 32-bit
myBuffer.pitch = myTexture->pitch/4;
break;
default:
break;
}
// Create an OpenGL texture from the SDL texture
const string& filter = myOSystem->settings().getString("gl_filter");
if(filter == "linear")
{
myBuffer.filter = GL_LINEAR;
myFilterParamName = "GL_LINEAR";
}
else if(filter == "nearest")
{
myBuffer.filter = GL_NEAREST;
myFilterParamName = "GL_NEAREST";
}
p_glGenTextures(1, &myBuffer.texture);
p_glBindTexture(myBuffer.target, myBuffer.texture);
p_glTexParameteri(myBuffer.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
p_glTexParameteri(myBuffer.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
p_glTexParameteri(myBuffer.target, GL_TEXTURE_MIN_FILTER, myBuffer.filter);
p_glTexParameteri(myBuffer.target, GL_TEXTURE_MAG_FILTER, myBuffer.filter);
// Finally, create the texture in the most optimal format
GLenum tex_intformat;
#if defined (MAC_OSX)
tex_intformat = GL_RGB5;
myBuffer.format = GL_BGRA;
myBuffer.type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
#else
tex_intformat = GL_RGB;
myBuffer.format = GL_RGB;
myBuffer.type = GL_UNSIGNED_SHORT_5_6_5;
#endif
p_glTexImage2D(myBuffer.target, 0, tex_intformat,
myBuffer.texture_width, myBuffer.texture_height, 0,
myBuffer.format, myBuffer.type, myBuffer.pixels);
return true;
} }
#if 0 #if 0

65
stella/src/common/FrameBufferGL.hxx
View File

@ -13,7 +13,7 @@
// See the file "license" for information on usage and redistribution of // See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES. // this file, and for a DISCLAIMER OF ALL WARRANTIES.
// //
// $Id: FrameBufferGL.hxx,v 1.55 2008-08-01 12:15:57 stephena Exp $ // $Id: FrameBufferGL.hxx,v 1.56 2008-08-05 12:54:47 stephena Exp $
//============================================================================ //============================================================================
#ifndef FRAMEBUFFER_GL_HXX #ifndef FRAMEBUFFER_GL_HXX
@ -27,6 +27,7 @@
class OSystem; class OSystem;
class GUI::Font; class GUI::Font;
class FBSurfaceGL;
#include "bspf.hxx" #include "bspf.hxx"
#include "FrameBuffer.hxx" #include "FrameBuffer.hxx"
@ -35,7 +36,7 @@ class GUI::Font;
This class implements an SDL OpenGL framebuffer. This class implements an SDL OpenGL framebuffer.
@author Stephen Anthony @author Stephen Anthony
@version $Id: FrameBufferGL.hxx,v 1.55 2008-08-01 12:15:57 stephena Exp $ @version $Id: FrameBufferGL.hxx,v 1.56 2008-08-05 12:54:47 stephena Exp $
*/ */
class FrameBufferGL : public FrameBuffer class FrameBufferGL : public FrameBuffer
{ {
@ -76,8 +77,7 @@ class FrameBufferGL : public FrameBuffer
@param g The green component of the color. @param g The green component of the color.
@param b The blue component of the color. @param b The blue component of the color.
*/ */
Uint32 mapRGB(Uint8 r, Uint8 g, Uint8 b) const Uint32 mapRGB(Uint8 r, Uint8 g, Uint8 b) const;
{ return SDL_MapRGB(myTexture->format, r, g, b); }
/** /**
This method is called to query the type of the FrameBuffer. This method is called to query the type of the FrameBuffer.
@ -151,20 +151,11 @@ class FrameBufferGL : public FrameBuffer
private: private:
bool loadFuncs(); bool loadFuncs();
bool createTextures();
static uInt32 power_of_two(uInt32 input)
{
uInt32 value = 1;
while( value < input )
value <<= 1;
return value;
}
private: private:
// Points to the current texture data // The TIA surface (wraps an SDL surface)
SDL_Surface* myTexture; FBSurfaceGL* myTiaSurface;
/*
// Holds all items specifically needed by GL commands // Holds all items specifically needed by GL commands
struct glBufferType struct glBufferType
{ {
@ -183,6 +174,7 @@ class FrameBufferGL : public FrameBuffer
int pitch; int pitch;
}; };
glBufferType myBuffer; glBufferType myBuffer;
*/
// Optional GL extensions that may increase performance // Optional GL extensions that may increase performance
bool myHaveTexRectEXT; bool myHaveTexRectEXT;
@ -207,16 +199,19 @@ class FrameBufferGL : public FrameBuffer
}; };
/** /**
A surface suitable for software rendering mode. A surface suitable for OpenGL rendering mode.
@author Stephen Anthony @author Stephen Anthony
@version $Id: FrameBufferGL.hxx,v 1.55 2008-08-01 12:15:57 stephena Exp $ @version $Id: FrameBufferGL.hxx,v 1.56 2008-08-05 12:54:47 stephena Exp $
*/ */
class FBSurfaceGL : public FBSurface class FBSurfaceGL : public FBSurface
{ {
friend class FrameBufferGL;
public: public:
FBSurfaceGL(const FrameBufferGL& buffer, SDL_Surface* surface, FBSurfaceGL(FrameBufferGL& buffer,
uInt32 w, uInt32 h, bool isBase); uInt32 baseWidth, uInt32 baseHeight,
uInt32 scaleWidth, uInt32 scaleHeight);
virtual ~FBSurfaceGL(); virtual ~FBSurfaceGL();
void hLine(uInt32 x, uInt32 y, uInt32 x2, int color); void hLine(uInt32 x, uInt32 y, uInt32 x2, int color);
@ -235,16 +230,38 @@ class FBSurfaceGL : public FBSurface
void update(); void update();
private: private:
inline void* pixels() const { return myTexture->pixels; }
inline uInt32 pitch() const { return myPitch; }
inline uInt32 mapRGB(Uint8 r, Uint8 g, Uint8 b) const
{ return SDL_MapRGB(myTexture->format, r, g, b); }
void recalc(); void recalc();
static uInt32 power_of_two(uInt32 input)
{
uInt32 value = 1;
while( value < input )
value <<= 1;
return value;
}
private: private:
const FrameBufferGL& myFB; FrameBufferGL& myFB;
SDL_Surface* myTexture; SDL_Surface* myTexture;
GLuint myTexID;
GLsizei myTexWidth;
GLsizei myTexHeight;
GLfloat myTexCoord[4];
GLenum myTexTarget;
GLenum myTexFormat;
GLenum myTexType;
GLint myTexFilter;
uInt32 myWidth, myHeight; uInt32 myWidth, myHeight;
bool myIsBaseSurface;
bool mySurfaceIsDirty; bool mySurfaceIsDirty;
int myBaseOffset; // int myBaseOffset;
int myPitch; uInt32 myPitch;
uInt32 myXOrig, myYOrig; uInt32 myXOrig, myYOrig;
uInt32 myXOffset, myYOffset; uInt32 myXOffset, myYOffset;