modules/subsys/native/include/pedigree/native/graphics/Graphics.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _GRAPHICS_H
#define _GRAPHICS_H

#include "pedigree/native/compiler.h"
#include "pedigree/native/types.h"

namespace PedigreeGraphics
{
class EXPORTED_PUBLIC Rect
{
  public:
    Rect();
    Rect(size_t x_, size_t y_, size_t width_, size_t height_);

    virtual ~Rect();

    void update(size_t x_, size_t y_, size_t w_, size_t h_);

    size_t getX() const;
    size_t getY() const;
    size_t getW() const;
    size_t getH() const;

  private:
    size_t x, y;
    size_t w, h;
};

enum PixelFormat
{
    Bits32_Argb,  // Alpha + RGB, with alpha in the highest byte
    Bits32_Rgba,  // RGB + alpha, with alpha in the lowest byte
    Bits32_Rgb,   // RGB, no alpha, essentially the same as above
    Bits32_Bgr,   // BGR, no alpha

    Bits24_Rgb,  // RGB in a 24-bit pack
    Bits24_Bgr,  // R and B bytes swapped

    Bits16_Argb,    // 4:4:4:4 ARGB, alpha most significant nibble
    Bits16_Rgb565,  // 5:6:5 RGB
    Bits16_Rgb555,  // 5:5:5 RGB

    Bits8_Idx,  // Index into a palette
    Bits8_Rgb332,
};

inline size_t bitsPerPixel(PixelFormat format)
{
    switch (format)
    {
        case Bits32_Argb:
        case Bits32_Rgba:
        case Bits32_Rgb:
        case Bits32_Bgr:
            return 32;
        case Bits24_Rgb:
        case Bits24_Bgr:
            return 24;
        case Bits16_Argb:
        case Bits16_Rgb565:
        case Bits16_Rgb555:
            return 16;
        case Bits8_Idx:
            return 8;
        default:
            return 4;
    }
}

inline size_t bytesPerPixel(PixelFormat format)
{
    return bitsPerPixel(format) / 8;
}

inline uint32_t createRgb(uint32_t r, uint32_t g, uint32_t b)
{
    return (r << 16) | (g << 8) | b;
}

struct Buffer
{
    uint32_t empty;
};

class Framebuffer;

struct GraphicsProvider
{
    void *pDisplay;

    /* Some form of hardware caps here... */
    bool bHardwareAccel;

    Framebuffer *pFramebuffer;

    size_t maxWidth;
    size_t maxHeight;
    size_t maxDepth;

    bool bReserved1;

    size_t contextId;
};

class Framebuffer
{
  public:
    Framebuffer();
    virtual ~Framebuffer();

    size_t getWidth();

    size_t getHeight();

    PedigreeGraphics::PixelFormat getFormat();

    size_t getBytesPerPixel();

    void setPalette(uint32_t *palette, size_t entries);

    void *getRawBuffer();

    Framebuffer *createChild(size_t x, size_t y, size_t w, size_t h);

    bool convertPixel(
        uint32_t source, PedigreeGraphics::PixelFormat srcFormat,
        uint32_t &dest, PedigreeGraphics::PixelFormat destFormat);

    PedigreeGraphics::Buffer *createBuffer(
        const void *srcData, PedigreeGraphics::PixelFormat srcFormat,
        size_t width, size_t height);

    void destroyBuffer(PedigreeGraphics::Buffer *pBuffer);

    void redraw(
        size_t x = ~0UL, size_t y = ~0UL, size_t w = ~0UL, size_t h = ~0UL,
        bool bChild = false);

    void blit(
        PedigreeGraphics::Buffer *pBuffer, size_t srcx, size_t srcy,
        size_t destx, size_t desty, size_t width, size_t height);

    void draw(
        void *pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
        size_t width, size_t height,
        PedigreeGraphics::PixelFormat format = PedigreeGraphics::Bits32_Argb);

    void rect(
        size_t x, size_t y, size_t width, size_t height, uint32_t colour,
        PedigreeGraphics::PixelFormat format = PedigreeGraphics::Bits32_Argb);

    void copy(
        size_t srcx, size_t srcy, size_t destx, size_t desty, size_t w,
        size_t h);

    void line(
        size_t x1, size_t y1, size_t x2, size_t y2, uint32_t colour,
        PedigreeGraphics::PixelFormat format = PedigreeGraphics::Bits32_Argb);

    void setPixel(
        size_t x, size_t y, uint32_t colour,
        PedigreeGraphics::PixelFormat format = PedigreeGraphics::Bits32_Argb);

    Framebuffer(GraphicsProvider &gfx);

    inline GraphicsProvider getProvider()
    {
        return m_Provider;
    }

  private:
    GraphicsProvider m_Provider;

    bool m_bProviderValid;

    bool m_bIsChild;
};

inline bool convertPixel(
    uint32_t source, PixelFormat srcFormat, uint32_t &dest,
    PixelFormat destFormat)
{
    if ((srcFormat == destFormat) || (!source))
    {
        dest = source;
        return true;
    }

    // Amount of red/green/blue, in 8-bit intensity values
    uint8_t amtRed = 0, amtGreen = 0, amtBlue = 0, amtAlpha = 0;

    // Unpack the pixel as necessary
    if ((srcFormat == Bits32_Argb) || (srcFormat == Bits32_Rgb) ||
        (srcFormat == Bits24_Rgb))
    {
        if (srcFormat != Bits24_Rgb)
            amtAlpha = (source & 0xff000000) >> 24;
        amtRed = (source & 0xff0000) >> 16;
        amtGreen = (source & 0xff00) >> 8;
        amtBlue = (source & 0xff);
    }
    else if (srcFormat == Bits32_Rgba)
    {
        amtRed = (source & 0xff000000) >> 24;
        amtGreen = (source & 0xff0000) >> 16;
        amtBlue = (source & 0xff00) >> 8;
        amtAlpha = (source & 0xff);
    }
    else if ((srcFormat == Bits32_Bgr) || (srcFormat == Bits24_Bgr))
    {
        amtBlue = (source & 0xff0000) >> 16;
        amtGreen = (source & 0xff00) >> 8;
        amtRed = (source & 0xff);
    }
    else if (srcFormat == Bits16_Argb)
    {
        amtAlpha = (((source & 0xF000) >> 12) / 0xF) * 0xFF;
        amtRed = (((source & 0xF00) >> 8) / 0xF) * 0xFF;
        amtGreen = (((source & 0xF0) >> 4) / 0xF) * 0xFF;
        amtBlue = ((source & 0xF) / 0xF) * 0xFF;
    }
    else if (srcFormat == Bits16_Rgb565)
    {
        amtRed = (((source & 0xF800) >> 11) / 0x1F) * 0xFF;
        amtGreen = (((source & 0x7E0) >> 5) / 0x3F) * 0xFF;
        amtBlue = ((source & 0x1F) / 0x1F) * 0xFF;
    }
    else if (srcFormat == Bits16_Rgb555)
    {
        amtRed = (((source & 0xF800) >> 10) / 0x1F) * 0xFF;
        amtGreen = (((source & 0x3E0) >> 5) / 0x1F) * 0xFF;
        amtBlue = ((source & 0x1F) / 0x1F) * 0xFF;
    }
    else if (srcFormat == Bits8_Rgb332)
    {
        amtRed = (((source & 0xE0) >> 5) / 0x7) * 0xFF;
        amtGreen = (((source & 0x1C) >> 2) / 0x7) * 0xFF;
        amtBlue = ((source & 0x3) / 0x3) * 0xFF;
    }

    // Conversion code. Complicated and ugly. :(
    switch (destFormat)
    {
        case Bits32_Argb:
            dest =
                (amtAlpha << 24) | (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits32_Rgba:
            dest =
                (amtRed << 24) | (amtGreen << 16) | (amtBlue << 8) | amtAlpha;
            return true;
        case Bits32_Rgb:
            dest = (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits24_Rgb:
            dest = (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits24_Bgr:
            dest = (amtBlue << 16) | (amtGreen << 8) | amtRed;
            return true;
        case Bits16_Rgb555:
            // 8-bit to 5-bit scaling. Lossy.
            amtRed >>= 3;
            amtGreen >>= 3;
            amtBlue >>= 3;

            dest = (amtRed << 10) | (amtGreen << 5) | (amtBlue);
            return true;
        case Bits16_Rgb565:
            // 8-bit to 5 and 6 -bit scaling. Lossy.
            amtRed >>= 3;
            amtGreen >>= 2;
            amtBlue >>= 3;

            dest = (amtRed << 11) | (amtGreen << 5) | (amtBlue);
            return true;
        case Bits16_Argb:
            // 8-bit to 4-bit scaling. Lossy.
            amtRed >>= 4;
            amtGreen >>= 4;
            amtBlue >>= 4;
            amtAlpha >>= 4;

            dest =
                (amtAlpha << 12) | (amtRed << 8) | (amtGreen << 4) | (amtBlue);
            return true;
        case Bits8_Idx:
            break;
        case Bits8_Rgb332:
            amtRed >>= 5;
            amtGreen >>= 5;
            amtBlue >>= 6;

            dest = (amtRed << 5) | (amtGreen << 2) | amtBlue;
            return true;
        default:
            break;
    }

    return false;
}
};  // namespace PedigreeGraphics

#endif