Framebuffer.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 _MACHINE_FRAMEBUFFER_H
#define _MACHINE_FRAMEBUFFER_H
 
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/graphics/Graphics.h"
#include "pedigree/kernel/processor/types.h"
 
class EXPORTED_PUBLIC Framebuffer {
 public:
  Framebuffer();
  virtual ~Framebuffer();
 
  size_t getWidth() const;
  size_t getHeight() const;
 
  Graphics::PixelFormat getFormat() const;
 
  bool getActive() const;
 
  void setActive(bool b);
 
  void setPalette(uint32_t* palette, size_t nEntries);
 
  uint32_t* getPalette() const;
 
  virtual void* getRawBuffer() const;
 
  virtual physical_uintptr_t getPhysicalPage(size_t offset) const;
 
  size_t getMappingFlags() const {
    return m_MappingFlags;
  }
  void setMappingFlags(size_t flags) {
    m_MappingFlags = flags;
  }
 
  virtual Graphics::Buffer* createBuffer(const void* srcData, Graphics::PixelFormat srcFormat,
                                         size_t width, size_t height, uint32_t* pPalette = 0);
 
  virtual void destroyBuffer(Graphics::Buffer* pBuffer);
 
  void redraw(size_t x = ~0UL, size_t y = ~0UL, size_t w = ~0UL, size_t h = ~0UL,
              bool bChild = false);
 
  virtual void blit(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
                    size_t width, size_t height, bool bLowestCall = true);
 
  virtual void draw(void* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
                    size_t width, size_t height,
                    Graphics::PixelFormat format = Graphics::Bits32_Argb, bool bLowestCall = true);
 
  virtual void rect(size_t x, size_t y, size_t width, size_t height, uint32_t colour,
                    Graphics::PixelFormat format = Graphics::Bits32_Argb, bool bLowestCall = true);
 
  virtual void copy(size_t srcx, size_t srcy, size_t destx, size_t desty, size_t w, size_t h,
                    bool bLowestCall = true);
 
  virtual void line(size_t x1, size_t y1, size_t x2, size_t y2, uint32_t colour,
                    Graphics::PixelFormat format = Graphics::Bits32_Argb, bool bLowestCall = true);
 
  void setPixel(size_t x, size_t y, uint32_t colour,
                Graphics::PixelFormat format = Graphics::Bits32_Argb, bool bLowestCall = true);
 
  size_t m_XPos;
  void setXPos(size_t x);
 
  size_t m_YPos;
  void setYPos(size_t y);
 
  size_t m_nWidth;
  void setWidth(size_t w);
 
  size_t m_nHeight;
  void setHeight(size_t h);
 
  Graphics::PixelFormat m_PixelFormat;
  void setFormat(Graphics::PixelFormat pf);
 
  size_t m_nBytesPerPixel;
  void setBytesPerPixel(size_t b);
  uint32_t getBytesPerPixel() const;
 
  size_t m_nBytesPerLine;
  void setBytesPerLine(size_t b);
  uint32_t getBytesPerLine() const;
 
  Framebuffer* m_pParent;
  void setParent(Framebuffer* p);
  Framebuffer* getParent() const;
 
  virtual void setFramebuffer(uintptr_t p);
 
 private:
  void swSetPixel(size_t x, size_t y, uint32_t colour,
                  Graphics::PixelFormat format = Graphics::Bits32_Argb);
 
 protected:
  // Base address of this framebuffer, set by whatever code inherits this
  // class, ideally in the constructor.
  uintptr_t m_FramebufferBase;
 
  uint32_t* m_Palette;
 
  bool m_bActive;
 
  Graphics::Buffer bufferFromSelf();
 
  virtual void draw(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
                    size_t width, size_t height, bool bLowestCall = true);
 
  void swBlit(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
              size_t width, size_t height);
 
  void swRect(size_t x, size_t y, size_t width, size_t height, uint32_t colour,
              Graphics::PixelFormat format);
 
  void swCopy(size_t srcx, size_t srcy, size_t destx, size_t desty, size_t w, size_t h);
 
  void swLine(size_t x1, size_t y1, size_t x2, size_t y2, uint32_t colour,
              Graphics::PixelFormat format);
 
  void swDraw(void* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty, size_t width,
              size_t height, Graphics::PixelFormat format = Graphics::Bits32_Argb,
              bool bLowestCall = true);
 
  void swDraw(Graphics::Buffer* pBuffer, size_t srcx, size_t srcy, size_t destx, size_t desty,
              size_t width, size_t height, bool bLowestCall = true);
 
  Graphics::Buffer* swCreateBuffer(const void* srcData, Graphics::PixelFormat srcFormat,
                                   size_t width, size_t height, uint32_t* pPalette);
 
  void swDestroyBuffer(Graphics::Buffer* pBuffer);
 
  virtual void hwRedraw(size_t x = ~0UL, size_t y = ~0UL, size_t w = ~0UL, size_t h = ~0UL);
 
 private:
  size_t m_MappingFlags = 0;
};
 
#endif