+Unity Runtime codeHEADmaster

1 files changed, 231 insertions, 0 deletions

diff --git a/Runtime/Export/GradientBindings.txt b/Runtime/Export/GradientBindings.txt
new file mode 100644
index 0000000..1e4671b
--- /dev/null
+++ b/Runtime/Export/GradientBindings.txt
@@ -0,0 +1,231 @@
+C++RAW
+
+#include "UnityPrefix.h"
+#include "Runtime/Math/Gradient.h"
+#include "Runtime/Math/Color.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+#include "Runtime/Scripting/ScriptingExportUtility.h"
+#include "Runtime/Scripting/ScriptingObjectWithIntPtrField.h"
+
+using namespace Unity;
+
+CSRAW
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Collections;
+using UnityEngine;
+
+namespace UnityEngine
+{
+
+// Color key used by Gradient
+STRUCT public GradientColorKey
+	
+	// Gradient color key
+	CSRAW public GradientColorKey (Color col, float time)
+	{
+		color = col;
+		this.time = time;
+	}
+	// color of key
+	CSRAW public Color color;
+
+	// time of the key (0 - 1)	
+	CSRAW public float time;
+END
+
+C++RAW
+
+struct MonoGradientColorKey
+{
+	ColorRGBAf color;
+	float time;
+};
+
+// Alpha key used by Gradient
+STRUCT public GradientAlphaKey
+
+	// Gradient alpha key
+	CSRAW public GradientAlphaKey (float alpha, float time)
+	{
+		this.alpha = alpha;
+		this.time = time;
+	}
+	
+	// alpha alpha of key
+	CSRAW public float alpha;
+	
+	// time of the key (0 - 1)
+	CSRAW public float time;
+END
+
+
+C++RAW
+
+struct MonoGradientAlphaKey
+{
+	float alpha;
+	float time;
+};
+
+C++RAW
+ static void CleanupGradientNEW(void* gradient){ delete ((GradientNEW*)gradient); } ;
+
+// Gradient used for animating colors
+CSRAW  [StructLayout (LayoutKind.Sequential)]
+
+THREAD_SAFE
+CLASS public Gradient
+	CSRAW internal IntPtr m_Ptr;
+	
+	THREAD_SAFE
+	CUSTOM private void Init () { 
+		self.SetPtr(new GradientNEW(), CleanupGradientNEW);
+	}
+		
+	THREAD_SAFE
+	CUSTOM private void Cleanup () { CleanupGradientNEW(self.GetPtr()); }
+		
+	CSRAW public Gradient ()  { 
+		Init (); 
+	}
+
+	CSRAW ~Gradient() { 
+		Cleanup ();	
+	}
+
+
+	// Calculate color at a given time
+	CUSTOM Color Evaluate (float time)
+	{
+		time = clamp01(time);
+		return self->Evaluate (time);
+	}
+
+	// Returns num keys converted or -1 if invalid conversion
+	C++RAW
+	int ConvertColorKeyArray (ScriptingArrayPtr scriptColorKeys, GradientNEW::ColorKey* colorKeys)
+	{
+		if (scriptColorKeys == SCRIPTING_NULL)
+		{
+			ErrorString("SetKeys: Invalid input ColorKey array");
+			return -1;
+		}
+	
+		int size = GetScriptingArraySize (scriptColorKeys);
+		if (size > kGradientMaxNumKeys)
+		{
+			ErrorString(Format("Max number of color keys is %d (given %d)", kGradientMaxNumKeys, size));
+			return -1;
+		}
+			
+		for (int i=0; i < size ; i++)
+		{
+			MonoGradientColorKey &key = Scripting::GetScriptingArrayElement<MonoGradientColorKey> (scriptColorKeys, i);
+			colorKeys[i].m_Color = key.color;
+			colorKeys[i].m_Time = key.time;
+		}
+		
+		return size;
+	}
+	
+	// Returns num keys converted or -1 if invalid conversion
+	C++RAW
+	int ConvertAlphaKeyArray (ScriptingArrayPtr scriptAlphaKeys, GradientNEW::AlphaKey* alphaKeys)
+	{
+		if (scriptAlphaKeys == SCRIPTING_NULL)
+		{
+			ErrorString("SetKeys: Invalid input AlphaKey array");
+			return -1;
+		}
+	
+		int size = GetScriptingArraySize (scriptAlphaKeys);
+		if (size > kGradientMaxNumKeys)
+		{
+			ErrorString(Format("Max number of alpha keys is %d (given %d)", kGradientMaxNumKeys, size));
+			return -1;
+		}
+			
+		for (int i=0; i < size ; i++)
+		{
+			MonoGradientAlphaKey &key = Scripting::GetScriptingArrayElement<MonoGradientAlphaKey> (scriptAlphaKeys, i);
+			alphaKeys[i].m_Alpha = key.alpha;
+			alphaKeys[i].m_Time = key.time;
+		}
+		
+		return size;
+	}	
+
+	CUSTOM_PROP GradientColorKey[] colorKeys
+	{
+		int numColorKeys = self->GetNumColorKeys ();
+		GradientNEW::ColorKey colorKeys[kGradientMaxNumKeys];
+		ColorRGBA32& firstKey = self->GetKey(0);
+		UInt16& firstColorTime = self->GetColorTime(0);
+		for(int i = 0; i < kGradientMaxNumKeys; i++)
+		{
+			colorKeys[i].m_Color = (&firstKey)[i];
+			colorKeys[i].m_Color.a = 255; // See alphaKeys for alpha values
+			colorKeys[i].m_Time = WordToNormalized((&firstColorTime)[i]);
+		}
+		return CreateScriptingArray (colorKeys, numColorKeys, MONO_COMMON.gradientColorKey);
+	}
+	{
+		GradientNEW::ColorKey colorKeys[kGradientMaxNumKeys];
+		int numColorKeys = ConvertColorKeyArray (value, colorKeys);
+		if (numColorKeys == -1)
+			return;
+		self->SetColorKeys(&colorKeys[0], numColorKeys);
+	}
+	
+	CUSTOM_PROP GradientAlphaKey[] alphaKeys
+	{
+		int numAlphaKeys = self->GetNumAlphaKeys ();
+		GradientNEW::AlphaKey alphaKeys[kGradientMaxNumKeys];
+		const ColorRGBA32& firstKey = self->GetKey(0);
+		const UInt16& firstAlphaTime = self->GetAlphaTime(0);
+		for(int i = 0; i < kGradientMaxNumKeys; i++)
+		{
+			alphaKeys[i].m_Alpha = ByteToNormalized((&firstKey)[i].a);
+			alphaKeys[i].m_Time = WordToNormalized((&firstAlphaTime)[i]);
+		}
+
+		return CreateScriptingArray (alphaKeys, numAlphaKeys, MONO_COMMON.gradientAlphaKey);	
+	}
+	{
+		GradientNEW::AlphaKey alphaKeys[kGradientMaxNumKeys];
+		int numAlphaKeys = ConvertAlphaKeyArray (value, alphaKeys);
+		if (numAlphaKeys == -1)
+			return;	
+		self->SetAlphaKeys(&alphaKeys[0], numAlphaKeys);
+	}
+
+	CONDITIONAL UNITY_EDITOR
+	CUSTOM_PROP internal Color constantColor
+	{
+		return self->GetConstantColor ();
+	}
+	{
+		self->SetConstantColor (value);
+	}
+
+	// Setup Gradient with an array of color keys and alpha keys
+	CUSTOM void SetKeys (GradientColorKey[] colorKeys, GradientAlphaKey[] alphaKeys)
+	{
+		GradientNEW::ColorKey colors[kGradientMaxNumKeys];
+		int numColorKeys = ConvertColorKeyArray (colorKeys, colors);
+		if (numColorKeys == -1)
+			return;
+	
+		GradientNEW::AlphaKey alphas[kGradientMaxNumKeys];
+		int numAlphaKeys = ConvertAlphaKeyArray (alphaKeys, alphas);
+		if (numAlphaKeys == -1)
+			return;	
+		
+		return self->SetKeys (&colors[0], numColorKeys, &alphas[0], numAlphaKeys);
+	}	
+END
+
+CSRAW } // end of UnityEngine
+