Revisions of Texture and PlatformBitmap Format types

librtt/Display/Rtt_BufferBitmap.cpp

@@ -25,7 +25,7 @@ BufferBitmap::BufferBitmap( Rtt_Allocator* allocator, size_t w, size_t h, Platfo
 	fWidth( (U32) w ),
 	fHeight( (U32) h ),
 	fProperties( 0 ),
-	fFormat( format ),
+	fFormat( format.GetValue() ),
 	fOrientation( orientation )
 {
 	Rtt_ASSERT( fData );
@@ -89,7 +89,7 @@ BufferBitmap::UprightHeight() const
 PlatformBitmap::Format
 BufferBitmap::GetFormat() const
 {
-	return (PlatformBitmap::Format)fFormat;
+	return (PlatformBitmap::FormatValue)fFormat;
 }
 
 bool

librtt/Display/Rtt_PlatformBitmap.cpp

@@ -16,6 +16,25 @@
 namespace Rtt
 {
 
+// ----------------------------------------------------------------------------
+
+ PlatformBitmap::Format::Format( FormatValue value )
+:	fValue( value )
+{
+}
+
+PlatformBitmap::FormatValue
+PlatformBitmap::Format::GetValue() const
+{
+	return (FormatValue)GetStockFormatAndFlag( fValue );
+}
+
+bool
+PlatformBitmap::Format::IsNonCore() const
+{
+	return HasFormatFlag( fValue );
+}
+
 // ----------------------------------------------------------------------------
 
 PlatformBitmap::PlatformBitmap()
@@ -50,7 +69,7 @@ PlatformBitmap::HitTest( Rtt_Allocator *context, int i, int j, U8 threshold ) co
 
 			int index = (int) bytesPerPixel * ( i + j*Width() );
 
-			switch ( format )
+			switch ( format.GetValue() )
 			{
 				case kMask:
 					{
@@ -134,7 +153,7 @@ PlatformBitmap::HasAlphaChannel() const
 
 	Format format = GetFormat();
 
-	switch ( format )
+	switch ( format.GetValue() )
 	{
 		case kRGBA:
 		case kBGRA:
@@ -143,6 +162,12 @@ PlatformBitmap::HasAlphaChannel() const
 			result = true;
 			break;
 		default:
+			if ( format.IsNonCore() )
+			{
+				FormatDetails details = FormatDetails::UnpackFromValue( format.GetBackingValue() );
+
+				result = -1 != details.fAlphaIndex;
+			}
 			break;
 	}
 
@@ -189,7 +214,7 @@ PlatformBitmap::IsLandscape() const
 size_t
 PlatformBitmap::BytesPerPixel( Format format )
 {
-	switch( format )
+	switch( format.GetValue() )
 	{
 		case kMask:
 			return 1;
@@ -203,6 +228,12 @@ PlatformBitmap::BytesPerPixel( Format format )
 		case kABGR:
 			return 4;
 		default:
+			if ( format.IsNonCore() )
+			{
+				FormatDetails details = FormatDetails::UnpackFromValue( format.GetBackingValue() );
+
+				return details.fBytesPerComponent * details.fNumComponents;
+			}
 			break;
 	}
 
@@ -259,7 +290,7 @@ PlatformBitmap::GetColorByteIndexesFor(
 	int blueIndexOut = -1;
 
 	// Fetch the color byte index by format and endianness.
-	switch (format)
+	switch ( format.GetValue() )
 	{
 		case PlatformBitmap::kRGB:
 			#ifdef Rtt_LITTLE_ENDIAN
@@ -325,8 +356,20 @@ PlatformBitmap::GetColorByteIndexesFor(
 			#endif
 			break;
 		default:
-			// New formats need to have a case above
-			Rtt_ASSERT_NOT_IMPLEMENTED();
+			if ( format.IsNonCore() )
+			{
+				FormatDetails details = FormatDetails::UnpackFromValue( format.GetBackingValue() );
+
+				redIndexOut = details.fRedIndex;
+				greenIndexOut = details.fGreenIndex;
+				blueIndexOut = details.fBlueIndex;
+				alphaIndexOut = details.fAlphaIndex;
+			}
+			else
+			{
+				// New formats need to have a case above
+				Rtt_ASSERT_NOT_IMPLEMENTED();
+			}
 			break;
 	}
 
@@ -371,7 +414,7 @@ PlatformBitmap::Unlock()
 void 
 PlatformBitmap::SwapRGB()
 {
-	if ( GetFormat() != kRGBA )
+	if ( GetFormat().GetValue() != kRGBA )
 		return;
 
 	char * pixels = const_cast<char *>( (const char *) GetBits( NULL ) );
@@ -402,6 +445,15 @@ PlatformBitmap::SwapBitmapRGB( char * pixels, int w, int h )
 
 // ----------------------------------------------------------------------------
 
+using FV1 = Texture::FormatValue;
+using FV2 = PlatformBitmap::FormatValue;
+
+// These details are basically frozen, but enforce them.
+Rtt_STATIC_ASSERT( (U32)FV1::kNumFormats == (U32)FV2::kNumFormats );
+Rtt_STATIC_ASSERT( (U32)( 1U << kStockFormatBits ) >= (U32)FV1::kNumFormats );
+
+// ----------------------------------------------------------------------------
+
 } // namespace Rtt
 
 // ----------------------------------------------------------------------------

librtt/Display/Rtt_PlatformBitmap.h

@@ -26,7 +26,7 @@ namespace Rtt
 class PlatformBitmap
 {
 	public:
-		typedef enum Format
+		typedef enum FormatValue
 		{
 			kUndefined = 0,
 			kMask,
@@ -38,7 +38,22 @@ class PlatformBitmap
 			kLUMINANCE_ALPHA,
 			kNumFormats
 		}
-		Format;
+		FormatValue;
+
+		class Format {
+		public:
+			Format( FormatValue value = kUndefined );
+
+			FormatValue GetValue() const;
+			U32 GetBackingValue() const { return fValue; }
+			void SetBackingValue( U32 value ) { fValue = value; }
+
+		public:
+			bool IsNonCore() const;
+
+		 private:
+			U32 fValue;
+		};
 
 	public:
 		typedef enum _Orientation
@@ -162,7 +177,7 @@ class PlatformBitmap
 		bool IsLandscape() const;
 
 		// TODO: Remove as this is subsumed by GetFormat();
-		Rtt_INLINE bool IsMask() const { return GetFormat() == kMask; }
+		Rtt_INLINE bool IsMask() const { return GetFormat().GetValue() == kMask; }
 
 	public:
 		RenderTypes::TextureFilter GetMagFilter() const { return (RenderTypes::TextureFilter)fMagFilter; }

librtt/Display/Rtt_PlatformBitmapTexture.cpp

@@ -53,7 +53,7 @@ PlatformBitmapTexture::ConvertFormat( PlatformBitmap::Format format )
 {
 	Texture::Format result = Texture::kRGBA;
 
-	switch ( format )
+	switch ( format.GetValue() )
 	{
 		case PlatformBitmap::kRGB:
 			result = Texture::kRGB;
@@ -88,7 +88,14 @@ PlatformBitmapTexture::ConvertFormat( PlatformBitmap::Format format )
 			result = Texture::kLuminanceAlpha;
 			break;
 		default:
-			Rtt_ASSERT_NOT_IMPLEMENTED();
+			if ( format.IsNonCore() )
+			{
+				result.SetBackingValue( format.GetBackingValue() );
+			}
+			else
+			{
+				Rtt_ASSERT_NOT_IMPLEMENTED();
+			}
 			break;
 	}
 

librtt/Display/Rtt_TextureResource.cpp

@@ -57,7 +57,7 @@ TextureResource::ConvertFormat( Texture::Format format )
 {
 	PlatformBitmap::Format result = PlatformBitmap::kRGBA;
 
-	switch ( format )
+	switch ( format.GetValue() )
 	{
 		case Texture::kRGB:
 			result = PlatformBitmap::kRGB;
@@ -79,7 +79,14 @@ TextureResource::ConvertFormat( Texture::Format format )
 		case Texture::kLuminance:
 		case Texture::kAlpha:
 		default:
-			Rtt_ASSERT_NOT_IMPLEMENTED();
+			if ( format.IsNonCore() )
+			{
+				result.SetBackingValue( format.GetBackingValue() );
+			}
+			else
+			{
+				Rtt_ASSERT_NOT_IMPLEMENTED();
+			}
 			break;
 	}
 

librtt/Display/Rtt_TextureResourceBitmap.cpp

@@ -46,6 +46,7 @@ TextureResourceBitmap::Create(
 
 	if( save_to_file )
 	{
+		// TODO? check if this can occur with non-built-in-formats (BufferBitmap currently just uses a U8)
 		bitmap = Rtt_NEW( allocator,
 							BufferBitmap( display.GetAllocator(),
 											w,

librtt/Display/Rtt_TextureResourceCanvas.cpp

@@ -57,7 +57,7 @@ TextureResourceCanvas* TextureResourceCanvas::Create(Rtt::TextureFactory &factor
 	Texture::Filter filter = RenderTypes::Convert( display.GetDefaults().GetMagTextureFilter() );
 	Texture::Wrap wrap = RenderTypes::Convert( display.GetDefaults().GetTextureWrapX() );
 
-	if (Texture::kLuminance == format)
+	if ( Texture::kLuminance == format.GetValue() )
 	{
 		format = Texture::kRGBA;
 	}

librtt/Renderer/Rtt_FrameBufferObject.h

@@ -18,6 +18,7 @@
 namespace Rtt
 {
 
+class BufferBitmap;
 class Texture;
 
 // ----------------------------------------------------------------------------
@@ -42,6 +43,8 @@ class FrameBufferObject : public CPUResource
 		U8 GetDepthBits() const { return fDepthBits; }
 		U8 GetStencilBits() const { return fStencilBits; }
 		bool GetMustClear() const { return fMustClear; }
+
+		static void Capture( BufferBitmap& bitmap, S32 x_in_pixels, S32 y_in_pixels, S32 w_in_pixels, S32 h_in_pixels );
 
 	private:
 		Texture* fTexture;