---

corona.h

Go to the documentation of this file.

#ifndef CORONA_H
#define CORONA_H


#ifndef __cplusplus
#error Corona requires C++
#endif


#include <stddef.h>


// DLLs in Windows should use the standard calling convention
#ifndef COR_CALL
#  if defined(WIN32) || defined(_WIN32)
#    define COR_CALL __stdcall
#  else
#    define COR_CALL
#  endif
#endif

// Export functions from the DLL
#ifndef COR_DECL
#  if defined(WIN32) || defined(_WIN32)
#    ifdef CORONA_EXPORTS
#      define COR_DECL __declspec(dllexport)
#    else
#      define COR_DECL
#    endif
#  else
#    define COR_DECL
#  endif
#endif


// evil "identifier is too long in debug information" warning
#ifdef _MSC_VER
#pragma warning(disable : 4786)
#endif


#define COR_FUNCTION(ret) extern "C" COR_DECL ret COR_CALL


namespace corona {

  enum FileFormat {
    FF_AUTODETECT = 0x0100,
    FF_PNG        = 0x0101,
    FF_JPEG       = 0x0102,
    FF_PCX        = 0x0103,
    FF_BMP        = 0x0104,
    FF_TGA        = 0x0105,
    FF_GIF        = 0x0106,
  };

  enum PixelFormat {
    PF_DONTCARE = 0x0200,  
    PF_R8G8B8A8 = 0x0201,  
    PF_R8G8B8   = 0x0202,  
    PF_I8       = 0x0203,  
    PF_B8G8R8A8 = 0x0204,  
    PF_B8G8R8   = 0x0205,  
  };

  enum CoordinateAxis {
    CA_X     = 0x0001,
    CA_Y     = 0x0002,
  };

  class DLLInterface {
  private:
    virtual void COR_CALL destroy() = 0;

  public:
    void operator delete(void* p) {
      if (p) {
        DLLInterface* i = static_cast<DLLInterface*>(p);
        i->destroy();
      }
    }
  };


  template<class Interface>
  class DLLImplementation : public Interface {
  public:
    virtual ~DLLImplementation() { }

    virtual void COR_CALL destroy() {
      delete this;
    }

    void operator delete(void* p) {
      ::operator delete(p);
    }
  };

  
  class Image : public DLLInterface {
  public:
    virtual int COR_CALL getWidth() = 0;

    virtual int COR_CALL getHeight() = 0;

    virtual PixelFormat COR_CALL getFormat() = 0;

    virtual void* COR_CALL getPixels() = 0;

    virtual void* COR_CALL getPalette() = 0;

    virtual int COR_CALL getPaletteSize() = 0;

    virtual PixelFormat COR_CALL getPaletteFormat() = 0;
  };


  class File : public DLLInterface {
  public:

    enum SeekMode {
      BEGIN,    
      CURRENT,  
      END       
    };

    virtual int COR_CALL read(void* buffer, int size) = 0;

    virtual int COR_CALL write(const void* buffer, int size) = 0;

    virtual bool COR_CALL seek(int position, SeekMode mode) = 0;

    virtual int COR_CALL tell() = 0;
  };


  class FileFormatDesc {
  protected:
    ~FileFormatDesc() { }

  public:
    virtual FileFormat getFormat() = 0;

    virtual const char* getDescription() = 0;

    virtual size_t getExtensionCount() = 0;
    virtual const char* getExtension(size_t i) = 0;
  };


  namespace hidden {

    // these are extern "C" so we don't mangle the names


    // API information

    COR_FUNCTION(const char*) CorGetVersion();

    COR_FUNCTION(FileFormatDesc**) CorGetSupportedReadFormats();
    COR_FUNCTION(FileFormatDesc**) CorGetSupportedWriteFormats();

    // creation

    COR_FUNCTION(Image*) CorCreateImage(
      int width,
      int height,
      PixelFormat format);

    COR_FUNCTION(Image*) CorCreateImageWithPixels(
      int width,
      int height,
      PixelFormat format,
      void* pixels);

    COR_FUNCTION(Image*) CorCreatePalettizedImage(
      int width,
      int height,
      PixelFormat format, // must be a palettized format
      int palette_size,
      PixelFormat palette_format);

    COR_FUNCTION(Image*) CorCloneImage(
      Image* source,
      PixelFormat format);

    // loading

    COR_FUNCTION(Image*) CorOpenImage(
      const char* filename,
      FileFormat file_format);

    COR_FUNCTION(Image*) CorOpenImageFromFile(
      File* file,
      FileFormat file_format);

    // saving

    COR_FUNCTION(bool) CorSaveImage(
      const char* filename,
      FileFormat file_format,
      Image* image);

    COR_FUNCTION(bool) CorSaveImageToFile(
      File* file,
      FileFormat file_format,
      Image* image);

    // conversion

    COR_FUNCTION(Image*) CorConvertImage(
      Image* image,
      PixelFormat format);

    COR_FUNCTION(Image*) CorConvertPalette(
      Image* image,
      PixelFormat palette_format);

    COR_FUNCTION(Image*) CorFlipImage(
      Image* image,
      int coordinate_axis);

    // files

    COR_FUNCTION(File*) CorOpenFile(const char* name, bool writeable);
    COR_FUNCTION(File*) CorCreateMemoryFile(const void* buffer, int size);

    // utility

    COR_FUNCTION(int) CorGetPixelSize(PixelFormat format);
  }


  /* PUBLIC API */


  inline const char* GetVersion() {
    return hidden::CorGetVersion();
  }


  inline FileFormatDesc** GetSupportedReadFormats() {
    return hidden::CorGetSupportedReadFormats();
  }

  inline FileFormatDesc** GetSupportedWriteFormats() {
    return hidden::CorGetSupportedWriteFormats();
  }


  inline Image* CreateImage(
    int width,
    int height,
    PixelFormat format,
    void* pixels = 0)
  {
    return hidden::CorCreateImageWithPixels(width, height, format, pixels);
  }

  inline Image* CreateImage(
    int width,
    int height,
    PixelFormat format,
    int palette_size,
    PixelFormat palette_format)
  {
    return hidden::CorCreatePalettizedImage(
      width, height, format,
      palette_size, palette_format);
  }

  inline Image* CloneImage(
    Image* source,
    PixelFormat format = PF_DONTCARE)
  {
    return hidden::CorCloneImage(source, format);
  }

  inline Image* OpenImage(
    const char* filename,
    PixelFormat pixel_format = PF_DONTCARE,
    FileFormat file_format = FF_AUTODETECT)
  {
    return hidden::CorConvertImage(
      hidden::CorOpenImage(filename, file_format),
      pixel_format);
  }

  inline Image* OpenImage(
    File* file,
    PixelFormat pixel_format = PF_DONTCARE,
    FileFormat file_format = FF_AUTODETECT)
  {
    return hidden::CorConvertImage(
      hidden::CorOpenImageFromFile(file, file_format),
      pixel_format);
  }

  inline Image* OpenImage(
    const char* filename,
    FileFormat file_format,
    PixelFormat pixel_format = PF_DONTCARE)
  {
    return OpenImage(filename, pixel_format, file_format);
  }

  inline Image* OpenImage(
    File* file,
    FileFormat file_format,
    PixelFormat pixel_format = PF_DONTCARE)
  {
    return OpenImage(file, pixel_format, file_format);
  }

  inline bool SaveImage(
    const char* filename,
    FileFormat file_format,
    Image* image)
  {
    return hidden::CorSaveImage(filename, file_format, image);
  }

  inline bool SaveImage(
    File* file,
    FileFormat file_format,
    Image* image)
  {
    return hidden::CorSaveImageToFile(file, file_format, image);
  }

  inline Image* ConvertImage(Image* source, PixelFormat format) {
    return hidden::CorConvertImage(source, format);
  }

  inline Image* ConvertPalette(Image* source, PixelFormat palette_format) {
    return hidden::CorConvertPalette(source, palette_format);
  }

  inline Image* FlipImage(Image* source, int coordinate_axis) {
    return hidden::CorFlipImage(source, coordinate_axis);
  }

  inline File* OpenFile(const char* filename, bool writeable) {
    return hidden::CorOpenFile(filename, writeable);
  }

  inline File* CreateMemoryFile(const void* buffer, int size) {
    return hidden::CorCreateMemoryFile(buffer, size);
  }

  inline int GetPixelSize(PixelFormat format) {
    return hidden::CorGetPixelSize(format);
  }

  inline bool IsDirect(PixelFormat format) {
    return (format == PF_R8G8B8A8 || format == PF_R8G8B8 ||
            format == PF_B8G8R8A8 || format == PF_B8G8R8);
  }

  inline bool IsPalettized(PixelFormat format) {
    return format == PF_I8;
  }

  inline int GetPaletteSize(PixelFormat format) {
    return (format == PF_I8 ? 256 : 0);
  }

}


#endif

---