display_client.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef PSP_GRAPHICS_H
#define PSP_GRAPHICS_H
 
#include "common/singleton.h"
#include "graphics/surface.h"
#include "common/system.h"
#include "backends/platform/psp/memory.h"
#include "backends/platform/psp/psppixelformat.h"
 
#define MAX_TEXTURE_SIZE 512
 
class DisplayManager;
class GuRenderer;
 
class DisplayClient {               // Abstract class
public:
    DisplayClient() {}
    bool isVisible() { return true; }
    bool isDirty() { return true; }
    void setClean() {}
    void render() {}
    virtual ~DisplayClient() {}
};
 
struct Vertex {
    float u, v;
    float x, y, z;
};
 
struct Point {
    int x;
    int y;
    Point() : x(0), y(0) {}
};
 
struct Dimensions {
    uint32 width;
    uint32 height;
    Dimensions() : width(0), height(0) {}
};
 
class Palette {
public:
    Palette() : _values(0), _numOfEntries(0) {}
    virtual ~Palette() { deallocate(); }
    bool allocate();
    void deallocate();
    void clear();
    void setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::Type bufferType);
    void setNumOfEntries(uint32 num) {  _numOfEntries = num; }
    uint32 getNumOfEntries() const { return _numOfEntries; }
    uint32 getSizeInBytes() const { return _pixelFormat.pixelsToBytes(_numOfEntries); }
    void set(byte *values) { setPartial(values, 0, _numOfEntries); }
    void setPartial(const byte *colors, uint start, uint num, bool supportsAlpha = false);
    void getPartial(byte *colors, uint start, uint num) const;
    uint32 getRawColorAt(uint32 position) const;
    uint32 getRGBAColorAt(uint32 position) const;
    void setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a);
    void setColorPositionAlpha(uint32 position, bool alpha);
    const byte *getRawValues() const { return _values; }
    byte *getRawValues() { return _values; }
    bool isAllocated() const { return (_values != 0); }
    PSPPixelFormat::Type getPixelFormat() const { return _pixelFormat.format; }
    void print(uint32 numToPrint = 0);                  // print to screen
 
protected:
    byte *_values;                  
    uint32 _numOfEntries;           
    PSPPixelFormat _pixelFormat;    
};
 
class Buffer {
public:
    enum HowToSize {
        kSizeByTextureSize, // buffer size is determined by power of 2 roundup for texture
        kSizeBySourceSize   // buffer size is determined by source size
    };
 
    Buffer() : _pixels(0), _width(0), _height(0)  {}
    virtual ~Buffer() { deallocate(); }
 
    // setters
    void setSize(uint32 width, uint32 height, HowToSize textureOrSource = kSizeByTextureSize);
    void setBitsPerPixel(uint32 bits) { _pixelFormat.bitsPerPixel = bits; }
    void setBytesPerPixel(uint32 bytes) { setBitsPerPixel(bytes << 3); }
    void setPixelFormat(PSPPixelFormat::Type type);
 
    // getters
    uint32 getWidth() const { return _width; }
    uint32 getWidthInBytes() const { return _pixelFormat.pixelsToBytes(getWidth()); }
    uint32 getHeight() const { return _height; }
    uint32 getSourceWidth() const { return _sourceSize.width; }
    uint32 getSourceWidthInBytes() const { return _pixelFormat.pixelsToBytes(_sourceSize.width); }
    uint32 getSourceHeight() const { return _sourceSize.height; }
    uint32 getTextureWidth() const { return _textureSize.width; }
    uint32 getTextureHeight() const { return _textureSize.height; }
    PSPPixelFormat::Type getPixelFormat() const { return _pixelFormat.format; }
    uint32 getBitsPerPixel() const { return _pixelFormat.bitsPerPixel; }
    uint32 getBytesPerPixel() const { return getBitsPerPixel() >> 3; } /* won't work for 4-bit */
    const byte *getPixels() const { return _pixels; }
    byte *getPixels() { return _pixels; }
    const byte *getBasePtr(int x, int y) const { return _pixels + _pixelFormat.pixelsToBytes((y * _width) + x); }
    byte *getBasePtr(int x, int y) { return _pixels + _pixelFormat.pixelsToBytes((y * _width) + x); }
    uint32 getSizeInBytes() const { return _pixelFormat.pixelsToBytes(_width * _height); }
 
    bool hasPalette();
    void copyFromArray(const byte *buffer, int pitch);
    void copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, uint32 recWidth, uint32 recHeight);
    void copyToArray(byte *dst, int pitch);
    bool allocate(bool inVram = false);
    void deallocate();
    bool isAllocated() const { return (_pixels != 0) ; }
    void clear();
    void flipNibbles();     // To handle peculiarities of PSP's 4 bit textures
    static uint32 scaleUpToPowerOfTwo(uint32 size);
    void print(uint32 mask, uint32 numToPrint = 0);
 
protected:
    friend class GuRenderer;
    byte *_pixels;
    uint32 _width;                  
    uint32 _height;                 
    Dimensions _textureSize;        
    Dimensions _sourceSize;         
    PSPPixelFormat _pixelFormat;    
};
 
class GuRenderer {
public:
    // Constructors
    GuRenderer() : _useGlobalScaler(false), _buffer(0), _palette(0),
                    _blending(false), _alphaReverse(false), _colorTest(false),
                    _keyColor(0), _fullScreen(false), _stretch(false), _stretchX(1.0f), _stretchY(1.0f) {}
    GuRenderer(Buffer *buffer, Palette *palette) :
                    _useGlobalScaler(false), _buffer(buffer), _palette(palette),
                    _blending(false), _alphaReverse(false), _colorTest(false),
                    _keyColor(0), _fullScreen(false), _stretch(false), _stretchX(1.0f), _stretchY(1.0f) {}
    static void setDisplayManager(DisplayManager *dm) { _displayManager = dm; } // Called by the Display Manager
 
    // Setters
    void setDrawSize(uint32 width, uint32 height) { // How big of an area to draw
        _drawSize.width = width;
        _drawSize.height = height;
    }
    void setDrawWholeBuffer() {                     // Draw the full size of the current buffer
        assert(_buffer);
        _drawSize.width = _buffer->getSourceWidth();
        _drawSize.height = _buffer->getSourceHeight();
    }
    void setBuffer(Buffer *buffer) { _buffer = buffer; }
    void setPalette(Palette *palette) { _palette = palette; }
    void setOffsetOnScreen(int x, int y) { _offsetOnScreen.x = x; _offsetOnScreen.y = y; }
    void setOffsetInBuffer(uint32 x, uint32 y) { _offsetInBuffer.x = x; _offsetInBuffer.y = y; }
    void setColorTest(bool value) { _colorTest = value; }
    void setKeyColor(uint32 value) { _keyColor = value; }
    void setAlphaBlending(bool value) { _blending = value; }
    void setAlphaReverse(bool value) { _alphaReverse = value; }
    void setFullScreen(bool value) { _fullScreen = value; }     // Shortcut for rendering
    void setUseGlobalScaler(bool value) { _useGlobalScaler = value; }   // Scale to screen
    void setStretch(bool active) { _stretch = active; }
    void setStretchXY(float x, float y) { _stretchX = x; _stretchY = y; }
 
    static void cacheInvalidate(void *pointer, uint32 size);
 
    void render();                          // Default rendering function. This should be good enough for most purposes
 
protected:
    // Gu functions
    void fillVertices(Vertex *vertices);    // Fill in vertices with coordinates
    void guProgramDrawBehavior();
    Vertex *guGetVertices();
    void guLoadTexture();
    void guLoadPalette();
    void guProgramTextureFormat();
    void guProgramTextureBitDepth();
    void guDrawVertices(Vertex *vertices);
 
    uint32 convertToGuPixelFormat(PSPPixelFormat::Type format);
    float scaleSourceToOutput(bool x, float offset);
    float stretch(bool x, float size);
 
    friend class MasterGuRenderer;
    Point _textureLoadOffset;       
    Point _offsetOnScreen;          
    Point _offsetInBuffer;          
    bool _useGlobalScaler;          
    Buffer *_buffer;
    Palette *_palette;
    static DisplayManager *_displayManager;
    Dimensions _drawSize;           
    bool _blending;
    bool _alphaReverse;             
    bool _colorTest;
    uint32 _keyColor;               
    bool _fullScreen;               
    bool _stretch;                  
    float _stretchX, _stretchY;
};
 
#endif /* PSP_SCREEN_H */