C# interface for sprite texture

BansheeEngine/Include/BsSpriteTexture.h

@@ -15,10 +15,43 @@ namespace BansheeEngine
 	{
 	public:
 		/**
-		 * @brief	Returns internal Texture that the sprite texture references.
+		 * @brief	Gets the internal texture that the sprite texture references.
 		 */
 		const HTexture& getTexture() const;
 
+		/**
+		 * @brief	Sets the internal texture that the sprite texture references.
+		 */
+		void setTexture(const HTexture& texture);
+
+		/**
+		 * @brief	Gets the offset into the referenced texture where the sprite starts.
+		 *
+		 * @return	Offset in UV coordinates, range [0, 1].
+		 */
+		Vector2 getOffset() const { return mUVOffset; }
+
+		/**
+		 * @brief	Sets the offset into the referenced texture where the sprite starts.
+		 *
+		 * @param	offset	Offset in UV coordinates, range [0, 1].
+		 */
+		void setOffset(const Vector2& offset) { mUVOffset = offset; }
+
+		/**
+		 * @brief	Gets the size of the sprite in the referenced texture.
+		 *
+		 * @return	Size in UV coordinates, range [0, 1].
+		 */
+		Vector2 getScale() const { return mUVScale; }
+
+		/**
+		 * @brief	Sets the size of the sprite in the referenced texture.
+		 *
+		 * @param	scale	Size in UV coordinates, range [0, 1].
+		 */
+		void setScale(const Vector2& scale) { mUVScale = scale; }
+
 		/**
 		 * @brief	Transforms wanted UV coordinates into coordinates you
 		 *			can use for sampling the internal texture.

BansheeEngine/Source/BsSpriteTexture.cpp

@@ -16,6 +16,11 @@ namespace BansheeEngine
 		return mAtlasTexture; 
 	}
 
+	void SpriteTexture::setTexture(const HTexture& texture)
+	{
+		mAtlasTexture = texture;
+	}
+
 	Vector2 SpriteTexture::transformUV(const Vector2& uv) const
 	{
 		return mUVOffset + uv * mUVScale;

MBansheeEngine/SpriteTexture.cs

@@ -1,4 +1,5 @@
-using System.Runtime.CompilerServices;
+using System;
+using System.Runtime.CompilerServices;
 
 namespace BansheeEngine
 {
@@ -35,8 +36,82 @@ namespace BansheeEngine
             Internal_CreateInstance(this, texture, uvOffset, uvScale);
         }
 
+        /// <summary>
+        /// Texture that the sprite texture references.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return Internal_GetTexture(mCachedPtr); }
+            set
+            {
+                IntPtr texturePtr = IntPtr.Zero;
+                if (value != null)
+                    texturePtr = value.GetCachedPtr();
+
+                Internal_SetTexture(mCachedPtr, texturePtr);
+            }
+        }
+
+        /// <summary>
+        /// Offset into the referenced texture where the sprite starts. In UV coordinates, range [0, 1].
+        /// </summary>
+        public Vector2 Offset
+        {
+            get { Vector2 value; Internal_GetOffset(mCachedPtr, out value); return value; }
+            set { Internal_SetOffset(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Size of the sprite in the referenced texture. In UV coordinates, range [0, 1].
+        /// </summary>
+        public Vector2 Scale
+        {
+            get { Vector2 value; Internal_GetScale(mCachedPtr, out value); return value; }
+            set { Internal_SetScale(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Returns width of the sprite texture in pixels.
+        /// </summary>
+        public int Width
+        {
+            get { return Internal_GetWidth(mCachedPtr); }
+        }
+
+        /// <summary>
+        /// Returns height of the sprite texture in pixels.
+        /// </summary>
+        public int Height
+        {
+            get { return Internal_GetHeight(mCachedPtr); }
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_CreateInstance(SpriteTexture instance, 
             Texture2D teture, Vector2 offset, Vector2 scale);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Texture2D Internal_GetTexture(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetTexture(IntPtr thisPtr, IntPtr value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetOffset(IntPtr thisPtr, out Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetOffset(IntPtr thisPtr, Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetScale(IntPtr thisPtr, out Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetScale(IntPtr thisPtr, Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetWidth(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetHeight(IntPtr thisPtr);
     }
 }

SBansheeEngine/Include/BsScriptSpriteTexture.h

@@ -50,5 +50,13 @@ namespace BansheeEngine
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
 		static void internal_createInstance(MonoObject* instance, MonoObject* texture, Vector2 offset, Vector2 scale);
+		static MonoObject* internal_GetTexture(ScriptSpriteTexture* thisPtr);
+		static void internal_SetTexture(ScriptSpriteTexture* thisPtr, ScriptTexture2D* value);
+		static void internal_GetOffset(ScriptSpriteTexture* thisPtr, Vector2* value);
+		static void internal_SetOffset(ScriptSpriteTexture* thisPtr, Vector2 value);
+		static void internal_GetScale(ScriptSpriteTexture* thisPtr, Vector2* value);
+		static void internal_SetScale(ScriptSpriteTexture* thisPtr, Vector2 value);
+		static UINT32 internal_GetWidth(ScriptSpriteTexture* thisPtr);
+		static UINT32 internal_GetHeight(ScriptSpriteTexture* thisPtr);
 	};
 }

SBansheeEngine/Source/BsScriptSpriteTexture.cpp

@@ -18,6 +18,38 @@ namespace BansheeEngine
 	void ScriptSpriteTexture::initRuntimeData()
 	{
 		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptSpriteTexture::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetTexture", &ScriptSpriteTexture::internal_GetTexture);
+		metaData.scriptClass->addInternalCall("Internal_SetTexture", &ScriptSpriteTexture::internal_SetTexture);
+		metaData.scriptClass->addInternalCall("Internal_GetOffset", &ScriptSpriteTexture::internal_GetOffset);
+		metaData.scriptClass->addInternalCall("Internal_SetOffset", &ScriptSpriteTexture::internal_SetOffset);
+		metaData.scriptClass->addInternalCall("Internal_GetScale", &ScriptSpriteTexture::internal_GetScale);
+		metaData.scriptClass->addInternalCall("Internal_SetScale", &ScriptSpriteTexture::internal_SetScale);
+		metaData.scriptClass->addInternalCall("Internal_GetWidth", &ScriptSpriteTexture::internal_GetWidth);
+		metaData.scriptClass->addInternalCall("Internal_GetHeight", &ScriptSpriteTexture::internal_GetHeight);
+	}
+
+	void ScriptSpriteTexture::_onManagedInstanceDeleted()
+	{
+		mManagedInstance = nullptr;
+
+		if (!mRefreshInProgress)
+			ScriptResourceManager::instance().destroyScriptResource(this);
+	}
+
+	void ScriptSpriteTexture::setNativeHandle(const HResource& resource) 
+	{ 
+		mTexture = static_resource_cast<SpriteTexture>(resource);
+	}
+
+	MonoObject* ScriptSpriteTexture::toManaged(const HSpriteTexture& texture)
+	{
+		if (texture == nullptr)
+			return nullptr;
+
+		ScriptSpriteTexture* scriptSpriteTex;
+		ScriptResourceManager::instance().getScriptResource(texture, &scriptSpriteTex, true);
+
+		return scriptSpriteTex->getManagedInstance();
 	}
 
 	void ScriptSpriteTexture::internal_createInstance(MonoObject* instance, MonoObject* texture, Vector2 offset, Vector2 scale)
@@ -37,27 +69,92 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptSpriteTexture::_onManagedInstanceDeleted()
+	MonoObject* ScriptSpriteTexture::internal_GetTexture(ScriptSpriteTexture* thisPtr)
 	{
-		mManagedInstance = nullptr;
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return nullptr;
 
-		if (!mRefreshInProgress)
-			ScriptResourceManager::instance().destroyScriptResource(this);
+		HTexture texture = spriteTexture->getTexture();
+		if (!texture.isLoaded())
+			return nullptr;
+
+		ScriptTexture2D* scriptTexture = nullptr;
+		ScriptResourceManager::instance().getScriptResource(texture, &scriptTexture, true);
+
+		return scriptTexture->getManagedInstance();
 	}
 
-	void ScriptSpriteTexture::setNativeHandle(const HResource& resource) 
-	{ 
-		mTexture = static_resource_cast<SpriteTexture>(resource);
+	void ScriptSpriteTexture::internal_SetTexture(ScriptSpriteTexture* thisPtr, ScriptTexture2D* value)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return;
+
+		HTexture texture;
+		if (value != nullptr)
+			texture = value->getTextureHandle();
+
+		spriteTexture->setTexture(texture);
 	}
 
-	MonoObject* ScriptSpriteTexture::toManaged(const HSpriteTexture& texture)
+	void ScriptSpriteTexture::internal_GetOffset(ScriptSpriteTexture* thisPtr, Vector2* value)
 	{
-		if (texture == nullptr)
-			return nullptr;
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+		{
+			*value = Vector2::ZERO;
+			return;
+		}
+		
+		*value = spriteTexture->getOffset();
+	}
 
-		ScriptSpriteTexture* scriptSpriteTex;
-		ScriptResourceManager::instance().getScriptResource(texture, &scriptSpriteTex, true);
+	void ScriptSpriteTexture::internal_SetOffset(ScriptSpriteTexture* thisPtr, Vector2 value)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return;
 
-		return scriptSpriteTex->getManagedInstance();
+		spriteTexture->setOffset(value);
+	}
+
+	void ScriptSpriteTexture::internal_GetScale(ScriptSpriteTexture* thisPtr, Vector2* value)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+		{
+			*value = Vector2::ZERO;
+			return;
+		}
+
+		*value = spriteTexture->getScale();
+	}
+
+	void ScriptSpriteTexture::internal_SetScale(ScriptSpriteTexture* thisPtr, Vector2 value)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return;
+
+		spriteTexture->setScale(value);
+	}
+
+	UINT32 ScriptSpriteTexture::internal_GetWidth(ScriptSpriteTexture* thisPtr)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return 0;
+
+		return spriteTexture->getWidth();
+	}
+
+	UINT32 ScriptSpriteTexture::internal_GetHeight(ScriptSpriteTexture* thisPtr)
+	{
+		HSpriteTexture spriteTexture = thisPtr->mTexture;
+		if (!spriteTexture.isLoaded())
+			return 0;
+
+		return spriteTexture->getHeight();
 	}
 }

TODO.txt

@@ -57,13 +57,12 @@ Ribek use:
  - When hiding a component in inspector, it doesn't immediately reposition the components below it
  - Having en empty component in inspector shows a small empty background, it shouldn't show anything
  - Component inspector for Renderable
- - Resource inspectors for: Texture, Mesh, Font, Shader, Script Code, Plain Text, Sprite Texture, GUISkin, StringTable, Prefab (just something basic for now)
+ - Resource inspectors for: Font, Shader, Script Code, Plain Text, Sprite Texture, GUISkin, StringTable, Prefab (just something basic for now)
  - Test release mode
  - Add temporary icon textures too all icon buttons currently containing only text so that Ribek can modify them
   - Also add dummy icons to toolbar (Open Project, Save Scene, Undo, Redo, Basic shapes, Camera, Renderable, Lights, Play, Pause, Step)
 
 Other polish:
- - C# interface for SpriteTexture
  - Add menu items:
   - Edit: Cut/Copy/Paste/Duplicate/Delete(need to make sure it works in Hierarchy, with shortcuts), View/Move/rotate/scale
   - Game Object (also add to context): Create(Empty, Empty Child, Camera, Renderable, Point/Spot/Directional Light), Apply prefab, Break prefab, Revert prefab