pixelbuffer.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 GRAPHICS_PIXELBUFFER_H
#define GRAPHICS_PIXELBUFFER_H
 
#include "common/types.h"
#include "common/endian.h"
#include "common/textconsole.h"
 
#include "graphics/pixelformat.h"
 
namespace Graphics {
 
class PixelBuffer {
public:
    PixelBuffer();
    PixelBuffer(const Graphics::PixelFormat &format, int buffersize, DisposeAfterUse::Flag dispose);
    PixelBuffer(const Graphics::PixelFormat &format, byte *buffer);
    PixelBuffer(const PixelBuffer &buf);
    ~PixelBuffer();
 
    void create(const Graphics::PixelFormat &format, int buffersize, DisposeAfterUse::Flag dispose);
    void create(int buffersize, DisposeAfterUse::Flag dispose);
 
    void set(const Graphics::PixelFormat &format, byte *buffer);
 
    void free();
 
    void clear(uint length);
 
    inline void setPixelAt(int pixel, uint32 value) {
        switch (_format.bytesPerPixel) {
        case 2:
            ((uint16 *) _buffer)[pixel] = value;
            return;
        case 3:
            pixel *= 3;
#if defined(SCUMM_BIG_ENDIAN)
            _buffer[pixel + 0] = (value >> 16) & 0xFF;
            _buffer[pixel + 1] = (value >> 8) & 0xFF;
            _buffer[pixel + 2] = value & 0xFF;
#elif defined(SCUMM_LITTLE_ENDIAN)
            _buffer[pixel + 0] = value & 0xFF;
            _buffer[pixel + 1] = (value >> 8) & 0xFF;
            _buffer[pixel + 2] = (value >> 16) & 0xFF;
#endif
            return;
        case 4:
            ((uint32 *) _buffer)[pixel] = value;
            return;
        }
        error("setPixelAt: Unhandled bytesPerPixel %d", int(_format.bytesPerPixel));
    }
    inline void setPixelAt(int pixel, const PixelBuffer &buf) { setPixelAt(pixel, buf, pixel); }
    inline void setPixelAt(int thisPix, const PixelBuffer &buf, int otherPix) {
        if (_format == buf._format) {
            memcpy(getRawBuffer(thisPix), buf.getRawBuffer(otherPix), _format.bytesPerPixel);
            return;
        }
        uint8 a, r, g, b;
        buf.getARGBAt(otherPix, a, r, g, b);
        setPixelAt(thisPix, a, r, g, b);
    }
    inline void setPixelAt(int pixel, uint8 r, uint8 g, uint8 b) { setPixelAt(pixel, _format.RGBToColor(r, g, b)); }
    inline void setPixelAt(int pixel, uint8 a, uint8 r, uint8 g, uint8 b) { setPixelAt(pixel, _format.ARGBToColor(a, r, g, b)); }
 
    inline void copyBuffer(int from, int length, const PixelBuffer &buf) { copyBuffer(from, from, length, buf); }
    void copyBuffer(int thisFrom, int otherFrom, int length, const PixelBuffer &buf);
 
    inline void shiftBy(int amount) { _buffer += amount * _format.bytesPerPixel; }
 
    inline uint32 getValueAt(int i) const {
        switch (_format.bytesPerPixel) {
        case 2:
            return ((uint16 *) _buffer)[i];
        case 3:
            i *= 3;
#if defined(SCUMM_BIG_ENDIAN)
            return (_buffer[i + 0] << 16) | (_buffer[i + 1] << 8) | _buffer[i + 2];
#elif defined(SCUMM_LITTLE_ENDIAN)
            return _buffer[i + 0] | (_buffer[i + 1] << 8) | (_buffer[i + 2] << 16);
#endif
        case 4:
            return ((uint32 *) _buffer)[i];
        }
        error("getValueAt: Unhandled bytesPerPixel %d", int(_format.bytesPerPixel));
    }
    inline void getRGBAt(int i, uint8 &r, uint8 &g, uint8 &b) const { _format.colorToRGB(getValueAt(i), r, g, b); }
    inline void getARGBAt(int i, uint8 &a, uint8 &r, uint8 &g, uint8 &b) const { _format.colorToARGB(getValueAt(i), a, r, g, b); }
 
    inline byte *getRawBuffer() const { return _buffer; }
    inline byte *getRawBuffer(int pixel) const { return _buffer + _format.bytesPerPixel * pixel; }
 
    inline const PixelFormat &getFormat() const { return _format; }
 
    PixelBuffer &operator=(const PixelBuffer &buf);
    PixelBuffer &operator=(byte *buffer);
 
    inline operator bool() const { return (_buffer); }
 
private:
    byte *_buffer;
    Graphics::PixelFormat _format;
    DisposeAfterUse::Flag _dispose;
};
 
}
#endif