(FEATURE / UNSTABLE) Graphics roundup: enhanced texture support + some miscellany

librtt/Core/Rtt_Math.h

@@ -64,6 +64,43 @@ template < > Rtt_TYPES_INLINE long double Abs< long double >( long double a ) {
 
 // ----------------------------------------------------------------------------
 
+#if defined( Rtt_WIN_ENV )
+    Rtt_INLINE unsigned int Rtt_Pop16( U16 v )
+    {
+		v -= ( ( v >> 1 ) & 0x5555 );
+
+		v = ( ( v >> 2 ) & 0x3333 ) + ( v & 0x3333 );
+		v = ( ( v >> 4 ) + v ) & 0x0F0F;
+
+		return ( ( v >> 8 ) + v ) & 0x00FF;
+    }
+
+    Rtt_INLINE unsigned int Rtt_Pop32( U32 v )
+    {
+        v -= ( v >> 1 ) & 0x55555555;
+
+        v = ( v & 0x33333333 ) + ( ( v >> 2 ) & 0x33333333 );
+
+        return ( ( v + ( v >> 4 ) & 0x0F0F0F0F ) * 0x01010101 ) >> 24;
+    }
+
+    Rtt_INLINE unsigned int Rtt_Pop64( U64 v )
+    {
+        v -= ( v >> 1 ) & 0x5555555555555555ULL;
+
+        v = ( v & 0x3333333333333333ULL ) + ( ( v >> 2 ) & 0x3333333333333333ULL );
+        v = ( v + ( v >> 4 ) ) & 0x0F0F0F0F0F0F0F0FULL;
+
+        return ( v * 0x0101010101010101ULL ) >> 56;
+    }
+#else
+	#define Rtt_Pop16 __builtin_popcount
+	#define Rtt_Pop32 __builtin_popcount
+	#define Rtt_Pop64 __builtin_popcountll
+#endif
+
+// ----------------------------------------------------------------------------
+
 } // Rtt
 
 #endif // __cplusplus

librtt/Core/Rtt_String.cpp

@@ -12,6 +12,7 @@
 #include "Core/Rtt_New.h"
 
 #include <string.h>
+#include <ctype.h>
 
 // ----------------------------------------------------------------------------
 
@@ -213,7 +214,7 @@ template<typename T, T kPrime, T kOffsetBasis>
 T
 GetHash( const char* buffer )
 {
-	// https://en.wikipedia.org/wiki/Fowler�Noll�Vo_hash_function
+	// https://en.wikipedia.org/wiki/Fowler�Noll�Vo_hash_function
     T hash = kOffsetBasis;
 
 	if ( NULL != buffer ) // if absent, interpret as empty string
@@ -322,6 +323,130 @@ String::RTrim(const char *trimChars)
 	}
 }
 
+// Encoding bit layout, for bytes 0-3:
+// 0 0 0 0 0 0 1 1 | 1 1 1 1 2 2 2 2 | 2 2 3 3 3 3 3 3
+
+enum {
+
+	#define COUNT_AND_OFFSET( NAME, COUNT, OFFSET ) kCount##NAME = COUNT, kOffset##NAME = OFFSET
+	#define AFTER_PREV( PREV ) kOffset##PREV + kCount##PREV
+	#define NEXT_COUNT_AND_OFFSET( NAME, OFFSET ) COUNT_AND_OFFSET( NAME, kMax##NAME - kMin##NAME + 1, OFFSET )
+
+	kMinUpper = 'A', kMaxUpper = 'Z',
+	kMinLower = 'a', kMaxLower = 'z',
+	kMinDigit = '0', kMaxDigit = '9',
+
+	NEXT_COUNT_AND_OFFSET( Upper, 0 ),
+	NEXT_COUNT_AND_OFFSET( Lower, AFTER_PREV( Upper ) ),
+	NEXT_COUNT_AND_OFFSET( Digit, AFTER_PREV( Lower ) ),
+	kOffsetUnderscore = AFTER_PREV( Digit ),
+	kOffsetNUL = kOffsetUnderscore + 1
+
+	#undef COUNT_AND_OFFSET
+	#undef AFTER_PREV
+	#undef NEXT_COUNT_AND_OFFSET
+
+};
+
+Rtt_STATIC_ASSERT( kOffsetNUL + 1 == 64 );
+
+int
+String::EncodeIdentifier( U8* buf, const char* ident, int maxTriples )
+{
+	if ( !isalpha( *ident ) && *ident != '_' )
+	{
+		Rtt_LogException( "ERROR: Identifier must begin with a letter or underscore, got '%c'", *ident );
+
+		return -1;
+	}
+
+	// TODO? empty string; maxTriples == 0
+
+	#define PLUS_1_PRED( COND, RESULT ) ( ( COND ) ? 1 + ( RESULT ) : 0 )
+	#define OFFSET_PLUS_1( CHAR, NAME ) PLUS_1_PRED( ( (U32)( CHAR - kMin##NAME ) ) <= ( (U32)( kMax##NAME - kMin##NAME ) ), kOffset##NAME + CHAR - kMin##NAME )
+
+	int k = 0, bufSize = maxTriples * 3, bad = 0;
+
+	do {
+		U8 work[4] = { kOffsetNUL, kOffsetNUL, kOffsetNUL, kOffsetNUL };
+
+		for (int j = 0; *ident && j < 4; ++ident, ++j)
+		{
+			int c = *ident;
+			U8 code = PLUS_1_PRED( 0 == c, kOffsetNUL ) | PLUS_1_PRED( '_' == c, kOffsetUnderscore ) |
+						OFFSET_PLUS_1( c, Upper ) | OFFSET_PLUS_1( c, Lower ) | OFFSET_PLUS_1( c, Digit );
+
+			bad = ( 0 == code ) ? c : bad;
+			work[j] = code - 1;
+		}
+
+		// This check prevents overflow, but will lead to bogus results. This is mainly
+		// intended to detect encodability, in which case the results are thrown away.
+		k = Min( k + 3, bufSize );
+
+		buf[k - 3] = ( work[0] << 2 ) | ( work[1] >> 4 );
+		buf[k - 2] = ( work[1] << 4 ) | ( work[2] >> 2 );
+		buf[k - 1] = ( work[2] << 6 ) | ( work[3] >> 0 );
+	} while ( *ident );
+
+	#undef PLUS_1_PRED
+	#undef OFFSET_PLUS_1
+
+	if ( bad )
+	{
+		Rtt_LogException( "ERROR: Non-identifier character(s) found, including %c", bad );
+
+		return -1;
+	}
+
+	return k;
+}
+
+bool 
+String::IsIdentifier( const char* name )
+{
+	U8 junk[3];
+
+	return EncodeIdentifier( junk, name, 1 ) > 0;
+}
+
+U32
+String::DecodeIdentifier( char* name, const U8* buf, int numTriples )
+{
+	const char* start = name;
+	for ( int i = 0; i < numTriples; i++, buf += 3 )
+	{
+		U32 b1 = buf[0], b2 = buf[1], b3 = buf[2];
+		U32 work[] = {
+			b1 >> 2,
+			( ( b1 & 0x3 ) << 4 ) | ( b2 >> 4 ),
+			( ( b2 & 0xF ) << 2 ) | ( b3 >> 6 ),
+			b3 & 0x3F,
+			kOffsetNUL
+		};
+
+		for ( int k = 0; work[k] < kOffsetNUL; ++k )
+		{
+			static const char kSymbols[] = 
+				"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+				"abcdefghijklmnopqrstuvwxyz"
+				"0123456789_";
+
+			*name++ = kSymbols[work[k]];
+		}
+	}
+
+	*name = 0;
+
+	return (U32)( name - start );
+}
+
+int
+String::IdentifierLengthToTriples( int length )
+{
+	return ( length + 3 ) / 4;
+}
+
 void
 String::AppendPathComponent(const char *pathComponent)
 {

librtt/Core/Rtt_String.h

@@ -142,10 +142,18 @@ class String
 		void LTrim(const char *trimChars);
 		void RTrim(const char *trimChars);
 
+		// Identifier operations
+
+		static int EncodeIdentifier( U8* buf, const char* ident, int maxTriples );
+		static bool IsIdentifier( const char* name );
+		static U32 DecodeIdentifier( char* name, const U8* buf, int numTriples );
+
+		static int IdentifierLengthToTriples( int length );
+
 		// Path operations
 
 		// Append the given string to the end of the path including one path separator
-		void AppendPathComponent(const char *);
+		void AppendPathComponent(const char *);	
 		// Remove the last path component from the string (noop if no path separators in string)
 		void RemovePathComponent();
 		// Ensure string ends with one path separator

librtt/Corona/CoronaGraphics.cpp

@@ -43,7 +43,8 @@
 CORONA_API
 int CoronaExternalPushTexture( lua_State *L, const CoronaExternalTextureCallbacks *callbacks, void* context)
 {
-    if ( callbacks->size != sizeof(CoronaExternalTextureCallbacks) )
+	// scoop up extensions, validate, etc.
+    if ( callbacks->size != sizeof(CoronaExternalTextureCallbacks) && callbacks->size != sizeof(CoronaExternalTextureCallbacks2) )
     {
         CoronaLuaError(L, "TextureResourceExternal - invalid binary version for callback structure; size value isn't valid");
         return 0;
@@ -55,6 +56,30 @@ int CoronaExternalPushTexture( lua_State *L, const CoronaExternalTextureCallback
         return 0;
     }
 
+    if ( sizeof(CoronaExternalTextureCallbacks2) == callbacks->size )
+    {
+		CoronaExternalTextureCallbacks2* callbacks2 = (CoronaExternalTextureCallbacks2*)callbacks;
+		if ( NULL == callbacks2->firstExtension )
+		{
+			CoronaLuaError(L, "TextureResourceExternal - no extensions provided to version 2 callbacks");
+			return 0;
+		}
+
+		U64 used = 0;
+		for ( const CoronaExternalTextureExtensionHeader* ext = callbacks2->firstExtension; NULL != ext; ext = ext->next )
+		{
+			U64 mask = 1U << ext->type;
+			if ( used & mask )
+			{
+				CoronaLuaError(L, "TextureResourceExternal - extension %i seen more than once", ext->type);
+				return 0;
+			}
+			used |= mask;
+		}
+		// TODO: at some point might want to validate certain combinations
+		// TODO: validate legal setups...
+    }
+
     static unsigned int sNextExternalTextureId = 1;
     char filename[30];
     snprintf(filename, 30, "corona://exTex_%u", sNextExternalTextureId++);
@@ -97,6 +122,87 @@ int CoronaExternalFormatBPP(CoronaExternalBitmapFormat format)
     }
 }
 
+
+// ----------------------------------------------------------------------------
+
+static Rtt::Renderer &
+GetRenderer( lua_State * L )
+{
+    return Rtt::LuaContext::GetRuntime( L )->GetDisplay().GetRenderer();
+}
+
+static int
+TryToCommitDescription( lua_State* L, Rtt::Renderer& renderer, const Rtt::TextureFormatDescription& desc )
+{
+	Rtt::TextureFactory& factory = Rtt::LuaContext::GetRuntime( L )->GetDisplay().GetTextureFactory();
+
+	if ( factory.AddCustomFormat( desc ) )
+	{
+		U32 count = factory.GetCurrentFormatCount();
+		Rtt_ASSERT( count > 0 );
+
+		renderer.UpdateCustomFormats( factory.GetCurrentFormatList(), count );
+
+		return count;
+	}
+	else
+	{
+		Rtt_TRACE_SIM(( "Too many texture formats defined" ));
+
+		return 0;
+	}
+}
+
+CORONA_API
+int CoronaDefineStandardTextureFormat( lua_State * L, const CoronaTextureFormatDetails * details, unsigned int componentCount, unsigned int bytesPerComponent )
+{
+    Rtt::Renderer& renderer = GetRenderer( L );
+    Rtt::TextureFormatDescription desc = Rtt::TextureFormatDescription::MakeStandard();
+
+	desc.fNumComponents = componentCount;
+	desc.fBytesPerComponent = bytesPerComponent;
+
+	if ( renderer.MatchToFormatDescription( &desc, details ) )
+    {
+		return TryToCommitDescription( L, renderer, desc );
+	}
+	return 0;
+}
+
+CORONA_API
+int CoronaDefineWordPackedTextureFormat( lua_State * L, const CoronaTextureFormatDetails * details, unsigned int bitCounts[4] )
+{
+    Rtt::Renderer& renderer = GetRenderer( L );
+    Rtt::TextureFormatDescription desc = Rtt::TextureFormatDescription::MakeWordPacked();
+
+    for ( int i = 0; i < 4; i++ )
+    {
+		desc.fSizes[i] = bitCounts[i];
+    }
+    desc.fFlags |= Rtt::TextureFormatDescription::kIsWordPacked;
+
+	if ( renderer.MatchToFormatDescription( &desc, details ) )
+    {
+		return TryToCommitDescription( L, renderer, desc );
+	}
+	return 0;
+}
+
+CORONA_API
+int CoronaDefineCompressedTextureFormat( lua_State * L, const CoronaCompressedTextureFormatDetails * details, unsigned int componentCount )
+{
+    Rtt::Renderer& renderer = GetRenderer( L );
+    Rtt::TextureFormatDescription desc = Rtt::TextureFormatDescription::MakeCompressed();
+
+    desc.fNumComponents = componentCount;
+
+	if ( renderer.MatchToFormatDescription( &desc, details ) )
+    {
+		return TryToCommitDescription( L, renderer, desc );
+	}
+	return 0;
+}
+
 // ----------------------------------------------------------------------------
 
 OBJECT_HANDLE_DEFINE_TYPE( Renderer );
@@ -107,12 +213,6 @@ OBJECT_HANDLE_DEFINE_TYPE( CommandBuffer );
 
 // ----------------------------------------------------------------------------
 
-static Rtt::Renderer &
-GetRenderer( lua_State * L )
-{
-    return Rtt::LuaContext::GetRuntime( L )->GetDisplay().GetRenderer();
-}
-
 CORONA_API
 void CoronaRendererInvalidate( lua_State * L )
 {
@@ -462,6 +562,15 @@ int CoronaGeometryUnregisterVertexExtension( lua_State * L, const char * name )
 CORONA_API
 int CoronaShaderGetEffectDetail( const CoronaShader * shader, int index, CoronaEffectDetail * detail )
 {
+	static bool sHasWarned;
+
+	if ( !sHasWarned )
+	{
+		Rtt_LogException( "WARNING: effect details likely to be deprecated" );
+
+		sHasWarned = true; // n.b. a bit flaky; won't refire on relaunch
+	}
+
     const Rtt::Shader * shaderObject = OBJECT_HANDLE_LOAD( Shader, shader );
 
     if (shaderObject)