kiss-lang/lime
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add snapshot for Lime legacy

Browse Source
This commit is contained in:
Joshua Granick
2014-11-12 22:20:57 -08:00
parent 3482813780
commit bdc7039b19
239 changed files with 92735 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
legacy/project/include/Surface.h Normal file
View File

@@ -0,0 +1,237 @@
#ifndef NME_SURFACE_H
#define NME_SURFACE_H
#include <Graphics.h>
#include <Utils.h>
#include <ByteArray.h>
#include <Filters.h>
#include "Hardware.h"
#include <nme/Texture.h>
#include <nme/ImageBuffer.h>
// ---- Surface API --------------
namespace nme
{
void HintColourOrder(bool inRedFirst);
extern int gTextureContextVersion;
class Surface : public ImageBuffer
{
public:
// Non-PO2 will generate dodgy repeating anyhow...
Surface() : mTexture(0), mVersion(0), mFlags(surfNotRepeatIfNonPO2), mAllowTrans(true) { };
// Implementation depends on platform.
static Surface *Load(const OSChar *inFilename);
static Surface *LoadFromBytes(const uint8 *inBytes,int inLen);
bool Encode( nme::ByteArray *outBytes,bool inPNG,double inQuality);
Surface *IncRef() { mRefCount++; return this; }
virtual unsigned int GetFlags() const { return mFlags; }
virtual void SetFlags(unsigned int inFlags) { mFlags = inFlags; }
virtual int GPUFormat() const { return Format(); }
virtual bool GetAllowTrans() const { return mAllowTrans; }
virtual void SetAllowTrans(bool inAllowTrans) { mAllowTrans = inAllowTrans; }
virtual void Clear(uint32 inColour,const Rect *inRect=0) = 0;
virtual void Zero() { Clear(0); }
virtual void createHardwareSurface() { }
virtual void destroyHardwareSurface() { }
virtual void dispose() { }
virtual void MakeTextureOnly() { /*printf("Dumping bits from Surface\n");*/ }
virtual void setGPUFormat( PixelFormat pf ) {}
virtual void multiplyAlpha () {}
virtual void unmultiplyAlpha() { }
int BytesPP() const { return Format()==pfAlpha ? 1 : 4; }
virtual RenderTarget BeginRender(const Rect &inRect,bool inForHitTest=false)=0;
virtual void EndRender()=0;
virtual void BlitTo(const RenderTarget &outTarget, const Rect &inSrcRect,int inPosX, int inPosY,
BlendMode inBlend, const BitmapCache *inMask,
uint32 inTint=0xffffff ) const = 0;
virtual void StretchTo(const RenderTarget &outTarget,
const Rect &inSrcRect, const DRect &inDestRect) const = 0;
virtual void BlitChannel(const RenderTarget &outTarget, const Rect &inSrcRect,
int inPosX, int inPosY,
int inSrcChannel, int inDestChannel ) const = 0;
Texture *GetTexture(HardwareContext *inHardware,int inPlane=0);
virtual HardwareRenderer *GetHardwareRenderer() { return 0; }
void Bind(HardwareContext &inHardware,int inSlot=0);
virtual Surface *clone() { return 0; }
virtual void getPixels(const Rect &inRect,uint32 *outPixels,bool inIgnoreOrder=false,bool inLittleEndian=false) { }
virtual void setPixels(const Rect &inRect,const uint32 *intPixels,bool inIgnoreOrder=false,bool inLittleEndian=false) { }
virtual void getColorBoundsRect(int inMask, int inCol, bool inFind, Rect &outRect)
{
outRect = Rect(0,0,Width(),Height());
}
virtual uint32 getPixel(int inX,int inY) { return 0; }
virtual void setPixel(int inX,int inY,uint32 inRGBA,bool inAlphaToo=false) { }
virtual void scroll(int inDX,int inDY) { }
virtual void colorTransform(const Rect &inRect, ColorTransform &inTransform) { }
virtual void applyFilter(Surface *inSrc, const Rect &inRect, ImagePoint inOffset, Filter *inFilter) { }
virtual void noise(unsigned int randomSeed, unsigned int low, unsigned int high, int channelOptions, bool grayScale) { }
void OnChanged() { mVersion++; }
int Version() const { return mVersion; }
protected:
mutable int mVersion;
Texture *mTexture;
virtual ~Surface();
unsigned int mFlags;
bool mAllowTrans;
};
// Helper class....
class AutoSurfaceRender
{
Surface *mSurface;
RenderTarget mTarget;
public:
AutoSurfaceRender(Surface *inSurface) : mSurface(inSurface),
mTarget(inSurface->BeginRender( Rect(inSurface->Width(),inSurface->Height()),false ) ) { }
AutoSurfaceRender(Surface *inSurface,const Rect &inRect) : mSurface(inSurface),
mTarget(inSurface->BeginRender(inRect,false)) { }
~AutoSurfaceRender() { mSurface->EndRender(); }
const RenderTarget &Target() { return mTarget; }
};
class SimpleSurface : public Surface
{
public:
SimpleSurface(int inWidth,int inHeight,PixelFormat inPixelFormat,int inByteAlign=4,int inGPUPixelFormat=-1);
PixelFormat Format() const { return mPixelFormat; }
int Width() const { return mWidth; }
int Height() const { return mHeight; }
const uint8 *GetBase() const { return mBase; }
uint8 *Edit(const Rect *inRect);
void Commit() { };
int GetStride() const { return mStride; }
int GPUFormat() const { return mGPUPixelFormat; }
void Clear(uint32 inColour,const Rect *inRect);
void Zero();
RenderTarget BeginRender(const Rect &inRect,bool inForHitTest);
void EndRender();
virtual void BlitTo(const RenderTarget &outTarget, const Rect &inSrcRect,int inPosX, int inPosY,
BlendMode inBlend, const BitmapCache *inMask,
uint32 inTint=0xffffff ) const;
virtual void StretchTo(const RenderTarget &outTarget,
const Rect &inSrcRect, const DRect &inDestRect) const;
virtual void BlitChannel(const RenderTarget &outTarget, const Rect &inSrcRect,
int inPosX, int inPosY,
int inSrcChannel, int inDestChannel ) const;
virtual void colorTransform(const Rect &inRect, ColorTransform &inTransform);
virtual void setGPUFormat( PixelFormat pf ) { mGPUPixelFormat = pf; }
void unmultiplyAlpha();
Surface *clone();
void getPixels(const Rect &inRect,uint32 *outPixels,bool inIgnoreOrder=false, bool inLittleEndian=false);
void setPixels(const Rect &inRect,const uint32 *intPixels,bool inIgnoreOrder=false, bool inLittleEndian=false);
void getColorBoundsRect(int inMask, int inCol, bool inFind, Rect &outRect);
uint32 getPixel(int inX,int inY);
void setPixel(int inX,int inY,uint32 inRGBA,bool inAlphaToo=false);
void scroll(int inDX,int inDY);
void applyFilter(Surface *inSrc, const Rect &inRect, ImagePoint inOffset, Filter *inFilter);
void noise(unsigned int randomSeed, unsigned int low, unsigned int high, int channelOptions, bool grayScale);
void createHardwareSurface();
void destroyHardwareSurface();
void dispose();
void MakeTextureOnly();
protected:
int mWidth;
int mHeight;
PixelFormat mPixelFormat;
int mGPUPixelFormat;
int mStride;
uint8 *mBase;
~SimpleSurface();
private:
SimpleSurface(const SimpleSurface &inRHS);
void operator=(const SimpleSurface &inRHS);
};
class HardwareSurface : public Surface
{
public:
HardwareSurface(HardwareRenderer *inContext);
PixelFormat Format() const { return pfHardware; }
int Width() const { return mHardware->Width(); }
int Height() const { return mHardware->Height(); }
const uint8 *GetBase() const { return 0; }
uint8 *Edit(const Rect *inRect=0) { return 0; }
void Commit() { }
int GetStride() const { return 0; }
void Clear(uint32 inColour,const Rect *inRect=0) { mHardware->Clear(inColour,inRect); }
RenderTarget BeginRender(const Rect &inRect,bool inForHitTest)
{
mHardware->BeginRender(inRect,inForHitTest);
return RenderTarget(inRect,mHardware);
}
void EndRender()
{
mHardware->EndRender();
}
HardwareRenderer *GetHardwareRenderer() { return mHardware; }
void BlitTo(const RenderTarget &outTarget, const Rect &inSrcRect,int inPosX, int inPosY,
BlendMode inBlend, const BitmapCache *inMask,
uint32 inTint ) const { }
void StretchTo(const RenderTarget &outTarget,
const Rect &inSrcRect, const DRect &inDestRect) const { }
void BlitChannel(const RenderTarget &outTarget, const Rect &inSrcRect,
int inPosX, int inPosY,
int inSrcChannel, int inDestChannel ) const { }
Surface *clone();
void getPixels(const Rect &inRect,uint32 *outPixels,bool inIgnoreOrder=false);
void setPixels(const Rect &inRect,const uint32 *intPixels,bool inIgnoreOrder=false);
protected:
~HardwareSurface();
private:
HardwareRenderer *mHardware;
};
} // end namespace nme
#endif