path: root/Runtime/Export/Graphics.txt

C++RAW

#include "UnityPrefix.h"
#include "Configuration/UnityConfigure.h"
#include "Runtime/Mono/MonoExportUtility.h"
#include "Runtime/Camera/Camera.h"
#include "Runtime/Camera/ImageFilters.h"
#include "Runtime/Camera/Light.h"
#include "Runtime/Camera/Skybox.h"
#include "Runtime/Graphics/LightmapSettings.h"
#include "Runtime/Filters/Renderer.h"
#include "Runtime/Camera/IntermediateRenderer.h"
#include "Runtime/Graphics/GraphicsHelper.h"
#include "Runtime/Graphics/Transform.h"
#include "Runtime/Shaders/Material.h"
#include "Runtime/Filters/Misc/TextMesh.h"
#include "Runtime/Filters/Particles/EllipsoidParticleEmitter.h"
#include "Runtime/Filters/Particles/MeshParticleEmitter.h"
#include "Runtime/Shaders/Shader.h"
#include "External/shaderlab/Library/intshader.h"
#include "Runtime/Camera/Renderqueue.h"
#include "Runtime/Filters/Deformation/SkinnedMeshFilter.h"
#include "Runtime/Camera/Flare.h"
#include "Runtime/GfxDevice/GfxDevice.h"
#include "External/shaderlab/Library/texenv.h"
#include "External/shaderlab/Library/properties.h"
#include "Runtime/Geometry/Ray.h"
#include "Runtime/Graphics/Texture2D.h"
#include "Runtime/Graphics/CubemapTexture.h"
#include "Runtime/Graphics/Texture3D.h"
#include "Runtime/Graphics/SpriteFrame.h"
#include "Runtime/Video/VideoTexture.h"
#include "Runtime/Camera/Projector.h"
#include "Runtime/Camera/RenderLayers/GUITexture.h"
#include "Runtime/Camera/RenderLayers/GUIText.h"
#include "Runtime/Camera/RenderLayers/GUILayer.h"
#include "Runtime/Filters/Misc/LineRenderer.h"
#include "Runtime/Graphics/DrawUtil.h"
#include "Runtime/Math/Quaternion.h"
#include "Runtime/Filters/Mesh/LodMesh.h"
#include "Runtime/Filters/Mesh/LodMeshFilter.h"
#include "Runtime/Graphics/RenderTexture.h"
#include "Runtime/Graphics/MatrixStack.h"
#include "Runtime/Filters/Misc/TrailRenderer.h"
#include "Runtime/Camera/LODGroupManager.h"
#include "Runtime/Graphics/RenderBufferManager.h"
#include "Runtime/Camera/RenderManager.h"
#include "Runtime/Shaders/GraphicsCaps.h"
#include "Runtime/Graphics/ScreenManager.h"
#include "Runtime/Misc/ResourceManager.h"
#include "Runtime/Geometry/Plane.h"
#include "Runtime/Filters/Particles/ParticleAnimator.h"
#include "Runtime/Filters/Particles/ParticleRenderer.h"
#include "Runtime/Mono/MonoBehaviour.h"
#include "Runtime/Filters/AABBUtility.h"
#include <list>
#include <vector>
#include "Runtime/Misc/QualitySettings.h"
#include "Runtime/Filters/Misc/Font.h"
#include "Runtime/Camera/RenderSettings.h"
#include "Runtime/Geometry/Intersection.h"
#include "Runtime/Shaders/ShaderNameRegistry.h"
#include "Runtime/Shaders/ShaderKeywords.h"
#include "Runtime/Shaders/ComputeShader.h"
#include "Runtime/Geometry/TextureAtlas.h"
#include "Runtime/Misc/GameObjectUtility.h"
#include "Runtime/Camera/CameraUtil.h"
#include "Runtime/Misc/Player.h"
#include "Runtime/Graphics/ImageConversion.h"
#include "Runtime/Filters/Mesh/MeshCombiner.h"
#include "Runtime/Filters/Mesh/MeshOptimizer.h"
#include "Runtime/Misc/BuildSettings.h"
#include "Runtime/Camera/Culler.h"
#include "Runtime/Threads/Mutex.h"
#include "Runtime/Threads/AtomicRefCounter.h"
#include "Runtime/Camera/OcclusionArea.h"
#include "Runtime/Camera/OcclusionPortal.h"
#include "Runtime/Graphics/DrawSplashScreenAndWatermarks.h"
#include "Runtime/Scripting/ScriptingUtility.h"
#include "Runtime/Scripting/ScriptingManager.h"
#include "Runtime/Scripting/Backend/ScriptingTypeRegistry.h"
#include "Runtime/Scripting/ScriptingExportUtility.h"
#include "Runtime/Utilities/BitUtility.h"
#include "Runtime/Profiler/Profiler.h"
#include "Runtime/IMGUI/GUIStyle.h"
#include "Runtime/Scripting/Backend/ScriptingBackendApi.h"
#include "Runtime/Scripting/Scripting.h"
#include "Runtime/Scripting/ScriptingObjectWithIntPtrField.h"
#include "Runtime/Graphics/TriStripper.h"
#include "Runtime/Misc/GraphicsScriptingUtility.h"

#if ENABLE_TEXTUREID_MAP
	#include "Runtime/GfxDevice/TextureIdMap.h"
#endif


#if !GAMERELEASE
#include "Editor/Src/Gizmos/GizmoManager.h"
#include "Editor/Src/Gizmos/GizmoUtil.h"
#endif


// matrix stacks to be able to support GL style Push/Pop
static MatrixStack g_WorldMatrixStack;
static MatrixStack g_ViewMatrixStack;
static MatrixStack g_ProjectionMatrixStack;
//

C++RAW


class MonoMaterialPropertyBlock : public MaterialPropertyBlock {
public:
	MonoMaterialPropertyBlock() : m_Counter() { }

	void Retain()
	{
		m_Counter.Retain();
	}

	void Release()
	{
		if( m_Counter.Release() ) {
			delete this;
		}
	}

	static void CleanupMonoMaterialPropertyBlock(void* mmpb)
	{
		if (NULL != mmpb)
			((MonoMaterialPropertyBlock*)mmpb)->Release();
	}

private:
	AtomicRefCounter m_Counter;
};


extern PPtr<Shader> s_ScriptingCurrentShader;
extern const ChannelAssigns* s_ScriptingCurrentChannels;


CSRAW
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Collections;

namespace UnityEngine
{

// The type of a [[Light]].
ENUM LightType
	// The light is a spot light.
	Spot = 0,

	// The light is a directional light.
	Directional = 1,

	// The light is a point light.
	Point = 2,

	// The light is an area light. It affects only lightmaps and lightprobes.
	Area = 3
END

// How the [[Light]] is rendered.
ENUM LightRenderMode
	// Automatically choose the render mode.
	Auto = 0,
	// Force the [[Light]] to be a pixel light.
	ForcePixel = 1,
	// Force the [[Light]] to be a vertex light.
	ForceVertex = 2
END

// Shadow casting options for a [[Light]].
ENUM LightShadows
	// Do not cast shadows (default).
	None = 0,
	// Cast "hard" shadows (with no shadow filtering).
	Hard = 1,
	// Cast "soft" shadows (with 4x PCF filtering).
	Soft = 2,
END


// OcclusionArea is an area in which occlusion culling is performed
CLASS OcclusionArea : Component

	// Center of the occlusion area relative to the transform
	AUTO_PROP Vector3 center GetCenter SetCenter

	// Size that the occlusion area will have
	AUTO_PROP Vector3 size GetSize SetSize

END

//The portal for dynamically changing occlusion at runtime.
CLASS OcclusionPortal : Component
	//gets / sets the portal's open state
	CUSTOM_PROP bool open { return self->GetIsOpen(); } { self->SetIsOpen(value); }
END


// Fog mode to use.
ENUM FogMode
	// Linear fog.
	Linear = 1,

	// Exponential fog.
	Exponential = 2,

	// Exponential squared fog (default).
	ExponentialSquared = 3
END


// The Render Settings contain values for a range of visual elements in your scene, like fog and ambient light.
CLASS RenderSettings : Object
	// Is fog enabled?
	CUSTOM_PROP static bool  fog           { return GetRenderSettings().GetUseFog();  }    { return GetRenderSettings().SetUseFog(value);  }

	// Fog mode to use.
	CUSTOM_PROP static FogMode fogMode     { return GetRenderSettings().GetFogMode();  }    { return GetRenderSettings().SetFogMode(value); }

	// The color of the fog.
	CUSTOM_PROP static Color fogColor      { return GetRenderSettings().GetFogColor(); }   { GetRenderSettings().SetFogColor(value); }

	// The density of the exponential fog.
	CUSTOM_PROP static float fogDensity    { return GetRenderSettings().GetFogDensity(); } { GetRenderSettings().SetFogDensity(value); }


	// The starting distance of linear fog.
	CUSTOM_PROP static float fogStartDistance { return GetRenderSettings().GetLinearFogStart(); } { GetRenderSettings().SetLinearFogStart(value); }

	// The ending distance of linear fog.
	CUSTOM_PROP static float fogEndDistance { return GetRenderSettings().GetLinearFogEnd(); } { GetRenderSettings().SetLinearFogEnd(value); }


	// Color of the scene's ambient light.
	CUSTOM_PROP static Color ambientLight  { return GetRenderSettings().GetAmbientLight(); }    { GetRenderSettings().SetAmbientLight(value); }

	// Size of the [[Light]] halos.
	CUSTOM_PROP static float haloStrength  { return GetRenderSettings().GetHaloStrength(); }  { GetRenderSettings().SetHaloStrength(value); }

	// The intensity of all flares in the scene.
	CUSTOM_PROP static float flareStrength { return GetRenderSettings().GetFlareStrength(); } { GetRenderSettings().SetFlareStrength(value); }

	// The fade speed of all flares in the scene.
	CUSTOM_PROP static float flareFadeSpeed { return GetRenderSettings().GetFlareFadeSpeed(); } { GetRenderSettings().SetFlareFadeSpeed(value); }

	// The global skybox to use.
	CUSTOM_PROP static Material skybox { return Scripting::ScriptingWrapperFor(GetRenderSettings().GetSkyboxMaterial()); } { GetRenderSettings().SetSkyboxMaterial(value); }
END

OBSOLETE warning See QualitySettings.names, QualitySettings.SetQualityLevel, and QualitySettings.GetQualityLevel
ENUM QualityLevel
	// The "fastest" quality level.
	Fastest = 0,
	// The "fast" quality level.
	Fast = 1,
	// The "simple" quality level.
	Simple = 2,
	// The "good" quality level.
	Good = 3,
	// The "beautiful" quality level.
	Beautiful = 4,
	// The "fantastic" quality level.
	Fantastic = 5,
END

// Shadow projection type for [[wiki:class-QualitySettings|Quality Settings]].
ENUM ShadowProjection
	// Close fit shadow maps with linear fadeout.
	CloseFit = 0,

	// Stable shadow maps with spherical fadeout.
	StableFit = 1,
END


// Script interface for [[wiki:class-QualitySettings|Quality Settings]].
CLASS QualitySettings : Object
	// The indexed list of available Quality Settings
	CONDITIONAL ENABLE_MONO || UNITY_WINRT
	CUSTOM_PROP static string[] names
	{
		return Scripting::StringVectorToMono(GetQualitySettings().GetQualitySettingsNames ());
	}

	// Returns the current graphics quality level.
	CUSTOM static int GetQualityLevel ()
	{
		return GetQualitySettings().GetCurrentIndex();
	}

	// Sets a new graphics quality level.
	CUSTOM static void SetQualityLevel (int index, bool applyExpensiveChanges = true)
	{
		GetQualitySettings().SetCurrentIndex (index, applyExpensiveChanges);
	}

	OBSOLETE warning Use GetQualityLevel and SetQualityLevel
	CUSTOM_PROP static QualityLevel currentLevel { return GetQualitySettings().GetCurrentIndex(); } { GetQualitySettings().SetCurrentIndex( value, true ); }

	// Increase the current quality level.
	CUSTOM static void IncreaseLevel(bool applyExpensiveChanges = false)
	{
		QualitySettings& q = GetQualitySettings();
		q.SetCurrentIndex( q.GetCurrentIndex() + 1, applyExpensiveChanges ); // will clamp internally
	}

	// Decrease the current quality level.
	CUSTOM static void DecreaseLevel(bool applyExpensiveChanges = false)
	{
		QualitySettings& q = GetQualitySettings();
		q.SetCurrentIndex( q.GetCurrentIndex() - 1, applyExpensiveChanges ); // will clamp internally
	}

	// The maximum number of pixel lights that should affect any object.
	CUSTOM_PROP static int pixelLightCount { return GetQualitySettings().GetCurrent().pixelLightCount; } { GetQualitySettings().SetPixelLightCount(value); }

	// Directional light shadow projection.
	CUSTOM_PROP static ShadowProjection shadowProjection { return (ShadowProjection)GetQualitySettings().GetCurrent().shadowProjection; } { GetQualitySettings().SetShadowProjection((ShadowProjection)value); }

	// Number of cascades to use for directional light shadows.
	CUSTOM_PROP static int shadowCascades { return GetQualitySettings().GetCurrent().shadowCascades; } { GetQualitySettings().SetShadowCascades(value); }

	// Shadow drawing distance.
	CUSTOM_PROP static float shadowDistance { return GetQualitySettings().GetCurrent().shadowDistance; } { GetQualitySettings().SetShadowDistance(value); }


	// A texture size limit applied to all textures.
	CUSTOM_PROP static int masterTextureLimit { return GetQualitySettings().GetCurrent().textureQuality; } { GetQualitySettings().SetMasterTextureLimit(value); }

	// Global anisotropic filtering mode.
	CUSTOM_PROP static AnisotropicFiltering anisotropicFiltering { return GetQualitySettings().GetCurrent().anisotropicTextures; } { GetQualitySettings().SetAnisotropicTextures(value); }

	// Global multiplier for the LOD's switching distance.
	CUSTOM_PROP static float lodBias { return GetQualitySettings().GetCurrent().lodBias; } { GetQualitySettings().SetLODBias (value); }

	// A maximum LOD level. All LOD groups
	CUSTOM_PROP static int maximumLODLevel { return GetQualitySettings().GetCurrent().maximumLODLevel; } { GetQualitySettings().SetMaximumLODLevel (value); }

	// Budget for how many ray casts can be performed per frame for approximate collision testing.
	CUSTOM_PROP static int particleRaycastBudget { return GetQualitySettings().GetCurrent().particleRaycastBudget; } { GetQualitySettings().SetParticleRaycastBudget (value); }

	// Use a two-pass shader for the vegetation in the terrain engine.
	CUSTOM_PROP static bool softVegetation { return GetQualitySettings().GetCurrent().softVegetation; } { GetQualitySettings().SetSoftVegetation (value); }


	// Maximum number of frames queued up by graphics driver.
	CUSTOM_PROP static int maxQueuedFrames { return GetGfxDevice().GetMaxBufferedFrames(); } { GetGfxDevice().SetMaxBufferedFrames (clamp(value, -1, 10)); }

	// The VSync Count.
	CUSTOM_PROP static int vSyncCount { return GetQualitySettings().GetCurrent().vSyncCount; } { GetQualitySettings().SetVSyncCount(value); }

	// Set The AA Filtering option.
	CUSTOM_PROP static int antiAliasing { return GetQualitySettings().GetCurrent().antiAliasing; } { GetQualitySettings().SetAntiAliasing(value); }

	// Desired color space
	CUSTOM_PROP static ColorSpace desiredColorSpace { return GetPlayerSettings().GetDesiredColorSpace (); }

	// Active color space
	CUSTOM_PROP static ColorSpace activeColorSpace { return GetPlayerSettings().GetValidatedColorSpace (); }

	// Blend weights.
	CUSTOM_PROP static BlendWeights blendWeights { return GetQualitySettings().GetCurrent().blendWeights; } { GetQualitySettings().SetBlendWeights(value); }
END



// Values for Camera.clearFlags, determining what to clear when rendering a [[Camera]].
ENUM CameraClearFlags
	// Clear with the skybox.
	Skybox = 1,

	OBSOLETE planned Use CameraClearFlags.SolidColor
	Color = 2,

	// Clear with a background color.
	SolidColor = 2,

	// Clear only the depth buffer.
	Depth = 3,

	// Don't clear anything.
	Nothing = 4
END


// Depth texture generation mode for [[Camera]].
CSRAW [Flags]
ENUM DepthTextureMode
	// Do not generate depth texture (Default).
	None = 0,

	// Generate a depth texture.
	Depth = 1,

	// Generate a depth + normals texture.
	DepthNormals = 2,
END

//*undocumented*
ENUM TexGenMode
	// the texture gets its coordinates from UV
	None  = 0,
	// The texture uses spherical reflection mappping
	SphereMap = 1,
	// The texture is applied in object space
	Object = 2,
	// Projected Eye space
	EyeLinear = 3,
	// Cubemap reflection calculation
	CubeReflect = 4,
	// Cubemap normal calculation
	CubeNormal = 5
END



// Anisotropic filtering mode.
ENUM AnisotropicFiltering
	// Disable anisotropic filtering for all textures.
	Disable = 0,
	// Enable anisotropic filtering, as set for each texture.
	Enable = 1,
	// Enable anisotropic filtering for all textures.
	ForceEnable = 2
END

// Blend weights.
ENUM BlendWeights
	// One bone affects each vertex.
	OneBone = 1,
	// Two bones affect each vertex.
	TwoBones = 2,
	// Four bones affect each vertex.
	FourBones = 4
END


CONDITIONAL UNITY_EDITOR
// Compression Quality. Corresponds to the settings in a [[wiki:class-Texture2D|texture inspector]].
ENUM TextureCompressionQuality
	// Fast compression
	Fast = 0,
	// Normal compression (default)
	Normal = 50,
	// Best compression
	Best = 100
END



// A class to access the [[Mesh]] of the [[wiki:class-MeshFilter|mesh filter]].
CLASS MeshFilter : Component

	// Returns the instantiated [[Mesh]] assigned to the mesh filter.
	AUTO_PTR_PROP Mesh mesh GetInstantiatedMesh SetInstantiatedMesh

	// Returns the shared mesh of the mesh filter.
	AUTO_PTR_PROP Mesh sharedMesh GetSharedMesh SetSharedMesh
END


// Struct used to describe meshes to be combined using Mesh.CombineMeshes.
STRUCT CombineInstance

	// [[Mesh]] to combine
	CSRAW public Mesh mesh { get { return InternalGetMesh(m_MeshInstanceID); } set { m_MeshInstanceID = value != null ? value.GetInstanceID() : 0; } }

	// Submesh index of the mesh
	CSRAW public int subMeshIndex { get { return m_SubMeshIndex; } set { m_SubMeshIndex = value; } }

	// Matrix to transform the mesh with before combining
	CSRAW public Matrix4x4 transform { get { return m_Transform; } set { m_Transform = value; } }

	CSRAW private int m_MeshInstanceID;
	CUSTOM private Mesh InternalGetMesh(int instanceID)
	{
		if(instanceID == 0)
			return SCRIPTING_NULL;
		return Scripting::ScriptingWrapperFor(PPtr<Mesh>(instanceID));
	}

	CSRAW private int m_SubMeshIndex;
	CSRAW private Matrix4x4 m_Transform;
END

C++RAW

struct MonoCombineInstance
{
	int meshInstanceID;
	int subMeshIndex;
	Matrix4x4f transform;
};

// Topology of [[Mesh]] faces.
ENUM MeshTopology

	// Mesh is made from triangles.
	Triangles = 0,

	// Mesh is made from quads.
	Quads = 2,

	// Mesh is made from lines.
	Lines = 3,

	// Mesh is a line strip.
	LineStrip = 4,

	// Mesh is made from points.
	Points = 5,
END


// A class that allows creating or modifying meshes from scripts.

CLASS Mesh : Object

	// Creates an empty mesh
	CSRAW public Mesh ()
	{
		Internal_Create(this);
	}

	CUSTOM private static void Internal_Create ([Writable]Mesh mono)
	{
		Mesh* mesh = NEW_OBJECT_MAIN_THREAD (Mesh);
		mesh->Reset();
		Scripting::ConnectScriptingWrapperToObject (mono.GetScriptingObject(), mesh);
		mesh->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);
	}

	// Clears all vertex data and all triangle indices.
	CUSTOM void Clear (bool keepVertexLayout = true)
	{
		self->Clear (keepVertexLayout);
	}

	// Returns state of the Read/Write Enabled checkbox when model was imported.
	AUTO_PROP bool isReadable GetIsReadable

	// Works like isReadable, except it also returns true in editor outside the game loop.
	CUSTOM_PROP internal bool canAccess { return self->CanAccessFromScript(); }

	// Returns a copy of the vertex positions or assigns a new vertex positions array.
	CUSTOM_PROP Vector3[] vertices
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().vector3;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelVertex))
				return CreateScriptingArrayStride<Vector3f>(self->GetChannelPointer(kShaderChannelVertex), self->GetVertexCount(), klass, self->GetStride(kShaderChannelVertex));
		}
		else
			ErrorStringMsg("Not allowed to access vertices on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
			self->SetVertices (Scripting::GetScriptingArrayStart<Vector3f>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access vertices on mesh '%s'", self->GetName());
	}

	// The normals of the mesh.
	CUSTOM_PROP Vector3[] normals
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().vector3;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelNormal))
				return CreateScriptingArrayStride<Vector3f>(self->GetChannelPointer(kShaderChannelNormal), self->GetVertexCount(), klass, self->GetStride(kShaderChannelNormal));
		}
		else
			ErrorStringMsg("Not allowed to access normals on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
		self->SetNormals (Scripting::GetScriptingArrayStart<Vector3f>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access normals on mesh '%s'", self->GetName());
	}

	// The tangents of the mesh.
	CUSTOM_PROP Vector4[] tangents
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().vector4;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelTangent))
				return CreateScriptingArrayStride<Vector4f>(self->GetChannelPointer(kShaderChannelTangent), self->GetVertexCount(), klass, self->GetStride(kShaderChannelTangent));
		}
		else
			ErrorStringMsg("Not allowed to access tangents on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
		self->SetTangents (Scripting::GetScriptingArrayStart<Vector4f>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access tangents on mesh '%s'", self->GetName());
	}

	// The base texture coordinates of the mesh.
	CUSTOM_PROP Vector2[] uv
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().vector2;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelTexCoord0))
				return CreateScriptingArrayStride<Vector2f>(self->GetChannelPointer(kShaderChannelTexCoord0), self->GetVertexCount(), klass, self->GetStride(kShaderChannelTexCoord0));
		}
		else
			ErrorStringMsg("Not allowed to access uv on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
			self->SetUv (0, Scripting::GetScriptingArrayStart<Vector2f>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access uv on mesh '%s'", self->GetName());
	}

	// The second texture coordinate set of the mesh, if present.
	CUSTOM_PROP Vector2[] uv2
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().vector2;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelTexCoord1))
				return CreateScriptingArrayStride<Vector2f>(self->GetChannelPointer(kShaderChannelTexCoord1), self->GetVertexCount(), klass, self->GetStride(kShaderChannelTexCoord1));
		}
		else
			ErrorStringMsg("Not allowed to access uv2 on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
			self->SetUv (1, Scripting::GetScriptingArrayStart<Vector2f>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access uv2 on mesh '%s'", self->GetName());
	}

	OBSOLETE planned Use uv2 instead
	CSRAW public Vector2[] uv1 { get { return uv2; } set { uv2 = value; } }

	// The bounding volume of the mesh.
	AUTO_PROP Bounds bounds GetBounds SetBounds


	// Vertex colors of the mesh.
	CUSTOM_PROP Color[] colors
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().color;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelColor))
			{
				ScriptingArrayPtr array = CreateScriptingArray<ColorRGBAf>(klass, self->GetVertexCount());
				self->ExtractColorArrayConverting (Scripting::GetScriptingArrayStart<ColorRGBAf>(array));
				return array;
			}
		}
		else
			ErrorStringMsg("Not allowed to access colors on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
			self->SetColorsConverting (Scripting::GetScriptingArrayStart<ColorRGBAf>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access colors on mesh '%s'", self->GetName());
	}

	// Vertex colors of the mesh.
	CUSTOM_PROP Color32[] colors32
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().color32;
		if (self->CanAccessFromScript())
		{
			if (self->IsAvailable(kShaderChannelColor))
			{
				ScriptingArrayPtr array = CreateScriptingArray<ColorRGBA32>(klass, self->GetVertexCount());
				self->ExtractColorArray (Scripting::GetScriptingArrayStart<ColorRGBA32>(array));
				return array;
			}
		}
		else
			ErrorStringMsg("Not allowed to access colors on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
			self->SetColors (Scripting::GetScriptingArrayStart<ColorRGBA32>(value), GetScriptingArraySize(value));
		else
			ErrorStringMsg("Not allowed to access colors on mesh '%s'", self->GetName());
	}

	// Recalculate the bounding volume of the mesh from the vertices.
	CUSTOM void RecalculateBounds ()
	{
		if (self->CanAccessFromScript())
			self->RecalculateBounds();
		else
			ErrorStringMsg("Not allowed to call RecalculateBounds() on mesh '%s'", self->GetName());
	}

	// Recalculates the normals of the mesh from the triangles and vertices.
	CUSTOM void RecalculateNormals ()
	{
		if (self->CanAccessFromScript())
			self->RecalculateNormals();
		else
			ErrorStringMsg("Not allowed to call RecalculateNormals() on mesh '%s'", self->GetName());
	}


	// Optimizes the mesh for display.
	CUSTOM void Optimize ()
	{
	}

	// An array containing all triangles in the mesh.
	//
	// If the mesh contains multiple sub meshes (materials) the triangle list will contain all triangles of all submeshes.
	CUSTOM_PROP int[] triangles
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().int_32;
		if (self->CanAccessFromScript())
		{
			Mesh::TemporaryIndexContainer triangles;
			self->GetTriangles(triangles);
			return CreateScriptingArray(&triangles[0], triangles.size(), klass);
		}
		else
			ErrorStringMsg("Not allowed to access triangles on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}
	{
		if (self->CanAccessFromScript())
		{
			self->SetSubMeshCount(1);
			self->SetIndices (Scripting::GetScriptingArrayStart<UInt32>(value), GetScriptingArraySize(value), 0, kPrimitiveTriangles);
		}
		else
			ErrorStringMsg("Not allowed to access triangles on mesh '%s'", self->GetName());
	}


	// Returns the triangle list for the submesh.
	CUSTOM int[] GetTriangles (int submesh)
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().int_32;
		if (self->CanAccessFromScript())
		{
			Mesh::TemporaryIndexContainer triangles;
			self->GetTriangles(triangles, submesh);
			return CreateScriptingArray(&triangles[0], triangles.size(), klass);
		}
		else
			ErrorStringMsg("Not allowed to call GetTriangles() on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}

	// Sets the triangle list for the submesh.
	CUSTOM void SetTriangles(int[] triangles, int submesh)
	{
		if (self->CanAccessFromScript())
		{
			self->SetIndices(Scripting::GetScriptingArrayStart<UInt32>(triangles), GetScriptingArraySize(triangles), submesh, kPrimitiveTriangles);
		}
		else
			ErrorStringMsg("Not allowed to call SetTriangles() on mesh '%s'", self->GetName());
	}


	// Returns the index buffer for the submesh.
	CUSTOM int[] GetIndices (int submesh)
	{
		ScriptingClassPtr klass = GetScriptingManager().GetCommonClasses().int_32;
		if (self->CanAccessFromScript())
		{
			Mesh::TemporaryIndexContainer indices;
			self->GetIndices (indices, submesh);
			return CreateScriptingArray(&indices[0], indices.size(), klass);
		}
		else
			ErrorStringMsg("Not allowed to call GetIndices() on mesh '%s'", self->GetName());

		return CreateEmptyStructArray(klass);
	}

	// Sets the index buffer for the submesh.
	CUSTOM void SetIndices (int[] indices, MeshTopology topology, int submesh)
	{
		if (self->CanAccessFromScript())
		{
			self->SetIndices(Scripting::GetScriptingArrayStart<UInt32>(indices), GetScriptingArraySize(indices), submesh, topology);
		}
		else
			ErrorStringMsg("Not allowed to call SetIndices() on mesh '%s'", self->GetName());
	}

	// Gets the topology of a submesh.
	CUSTOM MeshTopology GetTopology (int submesh)
	{
		if ((unsigned)submesh >= self->GetSubMeshCount())
		{
			ErrorString("Failed getting topology. Submesh index is out of bounds.");
			return kPrimitiveTriangles;
		}
		return self->GetSubMeshFast(submesh).topology;
	}

	// Returns the number of vertices in the mesh (RO).
	AUTO_PROP int vertexCount GetVertexCount

	// The number of submeshes. Every material has a separate triangle list.
	CUSTOM_PROP int subMeshCount
	{
		return self->GetSubMeshCount();
	}
	{
		if(value < 0)
		{
			ErrorString ("subMeshCount can't be set to negative value");
			return;
		}
		self->SetSubMeshCount(value);
	}

	//*undocumented* Internal api not really generally useful
	OBSOLETE warning Use SetTriangles instead. Internally this function will convert the triangle strip to a list of triangles anyway.
	CUSTOM void SetTriangleStrip (int[] triangles, int submesh)
	{
		UInt32* triStrip = Scripting::GetScriptingArrayStart<UInt32>(triangles);
		UNITY_TEMP_VECTOR(UInt32) newTriangles;
		Destripify(triStrip, GetScriptingArraySize(triangles), newTriangles);
		self->SetIndices (&newTriangles[0], newTriangles.size(), submesh, kPrimitiveTriangles);
	}

	//*undocumented* Internal api not really generally useful
	OBSOLETE warning Use GetTriangles instead. Internally this function converts a list of triangles to a strip, so it might be slow, it might be a mess.
	CUSTOM int[] GetTriangleStrip (int submesh)
	{
		Mesh::TemporaryIndexContainer triangles;
		self->GetTriangles(triangles, submesh);

		UNITY_TEMP_VECTOR(UInt32) strip;
		Stripify(&triangles[0], triangles.size(), strip);

		return CreateScriptingArray(&strip[0], strip.size(), GetScriptingManager().GetCommonClasses().int_32);
	}

	// Combines several meshes into this mesh.
	CUSTOM void CombineMeshes(CombineInstance[] combine, bool mergeSubMeshes = true, bool useMatrices = true)
	{
		CombineInstances combineVec;
		combineVec.resize(GetScriptingArraySize(combine));
		MonoCombineInstance* mono = Scripting::GetScriptingArrayStart<MonoCombineInstance>(combine);
		for (int i=0;i<combineVec.size();i++)
		{
			combineVec[i].transform = mono[i].transform;
			combineVec[i].subMeshIndex = mono[i].subMeshIndex;
			combineVec[i].mesh = PPtr<Mesh>(mono[i].meshInstanceID);
		}
		CombineMeshes(combineVec, *self, mergeSubMeshes, useMatrices);
	}


	// The bone weights of each vertex
	CUSTOM_PROP BoneWeight[] boneWeights
	{
		int size = self->GetVertexCount();
		BoneInfluence* weights = self->GetBoneWeights();
		return CreateScriptingArray(weights, size, MONO_COMMON.boneWeight);
	}
	{
		self->SetBoneWeights(Scripting::GetScriptingArrayStart<BoneInfluence> (value), GetScriptingArraySize(value));
	}

	// The bind poses. The bind pose at each index refers to the bone with the same index.
	CUSTOM_PROP Matrix4x4[] bindposes
	{
		return CreateScriptingArray(self->GetBindposes(), self->GetBindposeCount(), MONO_COMMON.matrix4x4);
	}
	{
		self->SetBindposes(Scripting::GetScriptingArrayStart<Matrix4x4f> (value), GetScriptingArraySize(value));
	}

	// Optimize mesh for frequent updates.
	CUSTOM void MarkDynamic ()
	{
		if (self->CanAccessFromScript())
			self->MarkDynamic();
	}

	CUSTOM void UploadMeshData(bool markNoLogerReadable)
	{
		if (self->CanAccessFromScript())
			self->UploadMeshData(markNoLogerReadable);
	}

	// Returns BlendShape count on this mesh.
	CUSTOM_PROP int blendShapeCount
	{
		return self->GetBlendShapeChannelCount();
	}

	// Returns name of BlendShape by given index.
	CUSTOM string GetBlendShapeName (int index)
	{
		return scripting_string_new(GetChannelName (self->GetBlendShapeData(), index));
	}

	// Calculates the index of the blendShape name
	CUSTOM int GetBlendShapeIndex(string blendShapeName)
	{
		return GetChannelIndex (self->GetBlendShapeData(), blendShapeName.AsUTF8().c_str());
	}

END

// Skinning bone weights of a vertex in the mesh.
STRUCT BoneWeight
	CSRAW private float m_Weight0;
	CSRAW private float m_Weight1;
	CSRAW private float m_Weight2;
	CSRAW private float m_Weight3;

	CSRAW private int m_BoneIndex0;
	CSRAW private int m_BoneIndex1;
	CSRAW private int m_BoneIndex2;
	CSRAW private int m_BoneIndex3;

	// Skinning weight for first bone.
	CSRAW public float weight0 { get { return m_Weight0; } set { m_Weight0 = value; } }
	// Skinning weight for second bone.
	CSRAW public float weight1 { get { return m_Weight1; } set { m_Weight1 = value; } }
	// Skinning weight for third bone.
	CSRAW public float weight2 { get { return m_Weight2; } set { m_Weight2 = value; } }
	// Skinning weight for fourth bone.
	CSRAW public float weight3 { get { return m_Weight3; } set { m_Weight3 = value; } }

	// Index of first bone.
	CSRAW public int boneIndex0 { get { return m_BoneIndex0; } set { m_BoneIndex0 = value; } }
	// Index of second bone.
	CSRAW public int boneIndex1 { get { return m_BoneIndex1; } set { m_BoneIndex1 = value; } }
	// Index of third bone.
	CSRAW public int boneIndex2 { get { return m_BoneIndex2; } set { m_BoneIndex2 = value; } }
	// Index of fourth bone.
	CSRAW public int boneIndex3 { get { return m_BoneIndex3; } set { m_BoneIndex3 = value; } }

	// used to allow BoneWeights to be used as keys in hash tables
	public override int GetHashCode() {
		return boneIndex0.GetHashCode() ^ (boneIndex1.GetHashCode()<<2) ^ (boneIndex2.GetHashCode()>>2) ^ (boneIndex3.GetHashCode()>>1)
			^ (weight0.GetHashCode() << 5) ^ (weight1.GetHashCode()<<4) ^ (weight2.GetHashCode()>>4) ^ (weight3.GetHashCode()>>3);
	}

	// also required for being able to use BoneWeights as keys in hash tables
	public override bool Equals(object other) {
		if(!(other is BoneWeight)) return false;

		BoneWeight rhs=(BoneWeight)other;
		return boneIndex0.Equals(rhs.boneIndex0)
			&& boneIndex1.Equals(rhs.boneIndex1)
			&& boneIndex2.Equals(rhs.boneIndex2)
			&& boneIndex3.Equals(rhs.boneIndex3)
			&& (new Vector4(weight0,weight1,weight2,weight3)).Equals(new Vector4(rhs.weight0,rhs.weight1,rhs.weight2,rhs.weight3));
	}

	//*undoc*
	CSRAW public static bool operator == (BoneWeight lhs, BoneWeight rhs)
	{
		return lhs.boneIndex0 == rhs.boneIndex0
			&& lhs.boneIndex1 == rhs.boneIndex1
			&& lhs.boneIndex2 == rhs.boneIndex2
			&& lhs.boneIndex3 == rhs.boneIndex3
			&& (new Vector4( lhs.weight0, lhs.weight1, lhs.weight2, lhs.weight3 )
				== new Vector4( rhs.weight0, rhs.weight1, rhs.weight2, rhs.weight3 ));
	}

	//*undoc*
	CSRAW public static bool operator != (BoneWeight lhs, BoneWeight rhs)
	{
		return !(lhs == rhs);
	}
END

/// The maximum number of bones affecting a single vertex
ENUM SkinQuality
	// Chooses the number of bones from the number current [[QualitySettings]] (Default)
	Auto = 0,
	// Use only 1 bone to deform a single vertex. (The most important bone will be used)
	Bone1 = 1,
	// Use 2 bones to deform a single vertex. (The most important bones will be used)
	Bone2 = 2,
	// Use 4 bones to deform a single vertex.
	Bone4 = 4
END

// The Skinned Mesh filter
NONSEALED_CLASS SkinnedMeshRenderer : Renderer

	// The bones used to skin the mesh.
	CUSTOM_PROP Transform[] bones
	{
		return CreateScriptingArrayFromUnityObjects(self->GetBones(), ClassID(Transform));
	}
	{
		dynamic_array<PPtr<Transform> > transforms;
		if (value != SCRIPTING_NULL)
		{
			int size = GetScriptingArraySize(value);
			transforms.resize_uninitialized(size);

			for (int i=0;i<size;i++)
			{
				int instanceID = Scripting::GetInstanceIDFromScriptingWrapper(Scripting::GetScriptingArrayElementNoRef<ScriptingObjectPtr>(value, i));
				transforms[i] = PPtr<Transform> (instanceID);
			}
		}

		self->SetBones(transforms);
	}

	AUTO_PTR_PROP Transform rootBone GetRootBone SetRootBone

	// The maximum number of bones affecting a single vertex
	AUTO_PROP SkinQuality quality GetQuality SetQuality

	// The mesh used for skinning
	AUTO_PTR_PROP Mesh sharedMesh GetMesh SetMesh

	OBSOLETE warning Has no effect.
	CSRAW public bool skinNormals  { get { return true; } set {} }

	// If enabled, the Skinned Mesh will be updated when offscreen. If disabled, this also disables updating animations.
	AUTO_PROP bool updateWhenOffscreen GetUpdateWhenOffscreen SetUpdateWhenOffscreen

	// AABB of this Skinned Mesh in its local space.
	CUSTOM_PROP Bounds localBounds
	{
		AABB result;
		self->GetSkinnedMeshLocalAABB(result);
		return result;
	}
	{
		self->SetLocalAABB(value);
	}

	// Creates a snapshot of SkinnedMeshRenderer and stores it in mesh.
	CUSTOM void BakeMesh (Mesh mesh)
	{
		self->BakeMesh(*mesh);
	}

	CONDITIONAL UNITY_EDITOR
	CUSTOM_PROP internal Transform actualRootBone { return Scripting::ScriptingWrapperFor(&self->GetActualRootBone()); }

	// Returns weight of BlendShape on this renderer.
	CUSTOM float GetBlendShapeWeight(int index) { return self->GetBlendShapeWeight(index); }

	// Sets weight of BlendShape on this renderer.
	CUSTOM void SetBlendShapeWeight(int index, float value) { self->SetBlendShapeWeight(index, value); }

END


// A flare asset. Read more about flares in the [[wiki:class-Flare|components reference]].
CLASS Flare : Object

END


// Script interface for a [[wiki:class-LensFlare|Lens flare component]].
CLASS LensFlare : Behaviour
	// The [[wiki:class-Flare|flare asset]] to use.
	AUTO_PTR_PROP Flare flare GetFlare SetFlare

	// The strength of the flare.
	AUTO_PROP float brightness GetBrightness SetBrightness

	// The fade speed of the flare.
	AUTO_PROP float fadeSpeed GetFadeSpeed SetFadeSpeed

	// The color of the flare.
	AUTO_PROP Color color GetColor SetColor
END


// General functionality for all renderers.
NONSEALED_CLASS Renderer : Component

	CUSTOM_PROP internal Transform staticBatchRootTransform { return Scripting::ScriptingWrapperFor (self->GetStaticBatchRoot ()); } { self->SetStaticBatchRoot (value); }

	CUSTOM_PROP internal int staticBatchIndex { return self->GetStaticBatchIndex(); }

	CUSTOM internal void SetSubsetIndex (int index, int subSetIndexForMaterial)
	{
		self->SetMaterialCount (std::max(index+1, self->GetMaterialCount()));
		self->SetSubsetIndex(index, subSetIndexForMaterial);
	}

	// Has this renderer been statically batched with any other renderers?
	CUSTOM_PROP bool isPartOfStaticBatch { return self->GetStaticBatchIndex() != 0; }

	// Matrix that transforms a point from world space into local space (RO).
	AUTO_PROP Matrix4x4 worldToLocalMatrix GetWorldToLocalMatrix
	// Matrix that transforms a point from local space into world space (RO).
	AUTO_PROP Matrix4x4 localToWorldMatrix GetLocalToWorldMatrix


	// Makes the rendered 3D object visible if enabled.
	AUTO_PROP bool enabled GetEnabled SetEnabled


	// Does this object cast shadows?
	AUTO_PROP bool castShadows GetCastShadows SetCastShadows


	// Does this object receive shadows?
	AUTO_PROP bool receiveShadows GetReceiveShadows SetReceiveShadows


	// The material of this object.

	CUSTOM_PROP Material material
	{
		return Scripting::ScriptingWrapperFor (self->GetAndAssignInstantiatedMaterial (0, false));
	}
	{
		self->SetMaterialCount (std::max(1, self->GetMaterialCount()));
		self->SetMaterial (value, 0);
	}


	// The shared material of this object.
	CUSTOM_PROP Material sharedMaterial
	{
		if (self->GetMaterialCount ())
			return Scripting::ScriptingWrapperFor (self->GetMaterial (0));
		else
			return Scripting::ScriptingObjectNULL (ScriptingClassFor (Material));
	}
	{
		self->SetMaterialCount (std::max(1, self->GetMaterialCount()));
		self->SetMaterial (value, 0);
	}


	// All the shared materials of this object.
	CUSTOM_PROP Material[] sharedMaterials
	{
		return CreateScriptingArrayFromUnityObjects(self->GetMaterialArray(), ClassID(Material));
	}
	{
#if ENABLE_MONO
		if (value == SCRIPTING_NULL)
			Scripting::RaiseNullException("material array is null");
#endif

		int size = GetScriptingArraySize(value);
		self->SetMaterialCount (size);
		for (int i=0;i<size;i++)
			self->SetMaterial (ScriptingObjectToObject<Material> (Scripting::GetScriptingArrayElementNoRef<ScriptingObjectPtr>(value, i)), i);
	}

	// All the materials of this object.
	CUSTOM_PROP Material[] materials
	{
		int length = self->GetMaterialCount();
		ScriptingArrayPtr array = CreateScriptingArray<ScriptingObjectPtr> (ScriptingClassFor(Material), length);

		for (int i=0;i<length;i++)
		{
			Material* instantiated = self->GetAndAssignInstantiatedMaterial(i, false);
			Scripting::SetScriptingArrayElement<ScriptingObjectPtr>(array,i,Scripting::ScriptingWrapperFor(instantiated));
		}

		return array;
	}
	{
		if (value == SCRIPTING_NULL)
			Scripting::RaiseNullException("material array is null");

		int size = GetScriptingArraySize(value);
		self->SetMaterialCount (size);
		for (int i=0;i<size;i++)
		{
			ScriptingObjectPtr o = Scripting::GetScriptingArrayElementNoRef<ScriptingObjectPtr>(value,i);
			self->SetMaterial (ScriptingObjectToObject<Material> (o), i);
		}
	}

	// The bounding volume of the renderer (RO).
	CUSTOM_PROP Bounds bounds { return CalculateWorldAABB (self->GetGameObject ()); }

	// The index of the lightmap applied to this renderer.
	CUSTOM_PROP int lightmapIndex { return self->GetLightmapIndexInt(); } { return self->SetLightmapIndexInt(value); }

	// The tiling & offset used for lightmap.
	CUSTOM_PROP Vector4 lightmapTilingOffset
	{
		Vector4f st = self->GetLightmapST();
		return Vector4f(st.x, st.y, st.z, st.w);
	}
	{
		Vector4f st( value.x, value.y, value.z, value.w );
		self->SetLightmapST( st );
	}

	// ''OnBecameVisible'' is called when the object became visible by any camera.
	CSNONE void OnBecameVisible();


	// ''OnBecameInvisible'' is called when the object is no longer visible by any camera.
	CSNONE void OnBecameInvisible();

	// Is this renderer visible in any camera? (RO)
	AUTO_PROP bool isVisible IsVisibleInScene

	// If enabled and baked light probes are present in the scene, an interpolated light probe
	AUTO_PROP bool useLightProbes GetUseLightProbes SetUseLightProbes

	// If set, Renderer will use this Transform's position to find the interpolated light probe;
	AUTO_PTR_PROP Transform lightProbeAnchor GetLightProbeAnchor SetLightProbeAnchor

	// Lets you add per-renderer material parameters without duplicating a material.
	CUSTOM void SetPropertyBlock (MaterialPropertyBlock properties)
	{
		if (properties.GetPtr())
			self->SetPropertyBlock (*properties);
		else
			self->ClearPropertyBlock ();
	}

	CUSTOM void GetPropertyBlock (MaterialPropertyBlock dest)
	{
		if (!dest.GetPtr())
			Scripting::RaiseNullException("dest property block is null");
		self->GetPropertyBlock (*dest);
	}


	CUSTOM_PROP string sortingLayerName
	{
		DISALLOW_IN_CONSTRUCTOR
		return scripting_string_new(self->GetSortingLayerName());
	}
	{
		DISALLOW_IN_CONSTRUCTOR 
		self->SetSortingLayerName(value);
	}
	AUTO_PROP int sortingLayerID GetSortingLayerUserID SetSortingLayerUserID
	AUTO_PROP int sortingOrder GetSortingOrder SetSortingOrder


	OBSOLETE planned No longer available
	CUSTOM void Render (int material)
	{
		Shader* shader = s_ScriptingCurrentShader;
		if (!shader) {
			ErrorString ("Render requires material.SetPass before!");
			return;
		}

		GfxDevice& device = GetGfxDevice();

		// D3D needs begin/end when rendering is called out-of-band
		#if UNITY_EDITOR
		bool outsideOfFrame = !device.IsInsideFrame();
		if( outsideOfFrame )
			device.BeginFrame();
		#endif

		float matWorld[16], matView[16];

		CopyMatrix(device.GetViewMatrix(), matView);
		CopyMatrix(device.GetWorldMatrix(), matWorld);

		Matrix4x4f transformMatrix;
		Matrix4x4f scaleOnly;
		float scale;
		TransformType matrixType = self->GetTransform().CalculateTransformMatrixDisableNonUniformScale (transformMatrix, scaleOnly, scale);
		SetupObjectMatrix (transformMatrix, matrixType);

		self->Render (material, *s_ScriptingCurrentChannels);
		device.SetViewMatrix(matView);
		device.SetWorldMatrix(matWorld);

		#if UNITY_EDITOR
		if( outsideOfFrame )
			device.EndFrame();
		#endif
	}
END



// A script interface for a [[wiki:class-Projector|projector component]].
CLASS Projector : Behaviour

	// The near clipping plane distance.
	AUTO_PROP float nearClipPlane GetNearClipPlane SetNearClipPlane

	// The far clipping plane distance.
	AUTO_PROP float farClipPlane GetFarClipPlane SetFarClipPlane

	// The field of view of the projection in degrees.
	AUTO_PROP float fieldOfView GetFieldOfView SetFieldOfView

	// The aspect ratio of the projection.
	AUTO_PROP float aspectRatio GetAspectRatio SetAspectRatio

	OBSOLETE planned Use orthographic instead
	CSRAW public bool isOrthoGraphic { get { return orthographic; } set { orthographic = value; } }

	// Is the projection orthographic (''true'') or perspective (''false'')?
	AUTO_PROP bool orthographic GetOrthographic SetOrthographic

	// Projection's half-size when in orthographic mode.
	AUTO_PROP float orthographicSize GetOrthographicSize SetOrthographicSize

	OBSOLETE planned use orthographicSize
	CSRAW public float orthoGraphicSize { get { return orthographicSize; } set { orthographicSize = value; } }

	// Which object layers are ignored by the projector.
	AUTO_PROP int ignoreLayers GetIgnoreLayers SetIgnoreLayers

	// The material that will be projected onto every object.
	AUTO_PTR_PROP Material material GetMaterial SetMaterial
END

// A script interface for the [[wiki:class-Skybox|skybox component]].
CLASS Skybox : Behaviour
	// The material used by the skybox.
	CUSTOM_PROP Material material { return Scripting::ScriptingWrapperFor (self->GetMaterial ()); } { self->SetMaterial (value); }
END


// A script interface for the [[wiki:class-TextMesh|text mesh component]].
CLASS TextMesh : Component

	// The text that is displayed.
	CUSTOM_PROP string text { return scripting_string_new (self->GetText ()); } { self->SetText (value); }

	// The [[Font]] used.
	AUTO_PTR_PROP Font font GetFont SetFont


	// The font size to use (for dynamic fonts)
	AUTO_PROP int fontSize GetFontSize SetFontSize

	// The font style to use (for dynamic fonts)
	AUTO_PROP FontStyle fontStyle GetFontStyle SetFontStyle

	// How far should the text be offset from the transform.position.z when drawing
	AUTO_PROP float offsetZ GetOffsetZ SetOffsetZ

	// How lines of text are aligned (Left, Right, Center)
	AUTO_PROP TextAlignment alignment GetAlignment SetAlignment

	// Which point of the text shares the position of the Transform
	AUTO_PROP TextAnchor anchor GetAnchor SetAnchor

	// The size of each character (This scales the whole text)
	AUTO_PROP float characterSize GetCharacterSize SetCharacterSize

	// How much space will be in-between lines of text
	AUTO_PROP float lineSpacing GetLineSpacing SetLineSpacing

	// How much space will be inserted for a tab '\t' character. This is a multiplum of the 'spacebar' character offset
	AUTO_PROP float tabSize GetTabSize SetTabSize

	// Enable HTML-style tags for Text Formatting Markup.
	AUTO_PROP bool richText GetRichText SetRichText

	// Base color in which to render the text
	AUTO_PROP Color color GetColor SetColor
END

//(Legacy Particle system)
STRUCT Particle
	CSRAW
	private Vector3 m_Position;
	private Vector3 m_Velocity;
	private float   m_Size;
	private float   m_Rotation;
	private float   m_AngularVelocity;
	private float   m_Energy;
	private float   m_StartEnergy;
	private Color   m_Color;

	// The position of the particle.
	CSRAW public Vector3 position { get { return m_Position; } set { m_Position = value; } }

	// The velocity of the particle.
	CSRAW public Vector3 velocity { get { return m_Velocity; } set { m_Velocity = value; } }

	// The energy of the particle.
	CSRAW public float   energy   { get { return m_Energy; }   set { m_Energy = value; } }

	// The starting energy of the particle.
	CSRAW public float   startEnergy   { get { return m_StartEnergy; }   set { m_StartEnergy = value; } }

	// The size of the particle.
	CSRAW public float   size     { get { return m_Size; }     set { m_Size = value; } }

	// The rotation of the particle.
	CSRAW public float   rotation     { get { return m_Rotation; }     set { m_Rotation = value; } }

	// The angular velocity of the particle.
	CSRAW public float   angularVelocity     { get { return m_AngularVelocity; }     set { m_AngularVelocity = value; } }

	// The color of the particle.
	CSRAW public Color   color    { get { return m_Color; }    set { m_Color = value; } }
END

// Simple struct that contains all the arguments needed by the internal DrawTexture.
STRUCT internal InternalEmitParticleArguments
	CSRAW public Vector3 pos;
	CSRAW public Vector3 velocity;
	CSRAW public float size;
	CSRAW public float energy;
	CSRAW public Color color;
	CSRAW public float rotation;
	CSRAW public float angularVelocity;
END

C++RAW

struct MonoInternalEmitParticleArguments {
	Vector3f pos;
	Vector3f velocity;
	float size;
	float energy;
	ColorRGBAf color;
	float rotation;
	float angularVelocity;
};

// (Legacy Particles) Script interface for particle emitters.
CLASS ParticleEmitter : Component

	// Should particles be automatically emitted each frame?
	AUTO_PROP bool emit IsEmitting SetEmit

	// The minimum size each particle can be at the time when it is spawned.
	AUTO_PROP float minSize GetMinSize SetMinSize

	// The maximum size each particle can be at the time when it is spawned.
	AUTO_PROP float maxSize GetMaxSize SetMaxSize

	// The minimum lifetime of each particle, measured in seconds.
	AUTO_PROP float minEnergy GetMinEnergy SetMinEnergy

	// The maximum lifetime of each particle, measured in seconds.
	AUTO_PROP float maxEnergy GetMaxEnergy SetMaxEnergy

	// The minimum number of particles that will be spawned every second.
	AUTO_PROP float minEmission GetMinEmission SetMinEmission

	// The maximum number of particles that will be spawned every second.
	AUTO_PROP float maxEmission GetMaxEmission SetMaxEmission

	// he amount of the emitter's speed that the particles inherit.
	AUTO_PROP float emitterVelocityScale GetEmitterVelocityScale SetEmitterVelocityScale

	// The starting speed of particles in world space, along X, Y, and Z.
	AUTO_PROP Vector3 worldVelocity GetWorldVelocity SetWorldVelocity

	// The starting speed of particles along X, Y, and Z, measured in the object's orientation.
	AUTO_PROP Vector3 localVelocity GetLocalVelocity SetLocalVelocity

	// A random speed along X, Y, and Z that is added to the velocity.
	AUTO_PROP Vector3 rndVelocity GetRndVelocity SetRndVelocity

	// If enabled, the particles don't move when the emitter moves. If false, when you move the emitter, the particles follow it around.
	AUTO_PROP bool useWorldSpace GetUseWorldSpace SetUseWorldSpace

	// If enabled, the particles will be spawned with random rotations.
	AUTO_PROP bool rndRotation GetRndRotation SetRndRotation

	// The angular velocity of new particles in degrees per second.
	AUTO_PROP float angularVelocity GetAngularVelocity SetAngularVelocity

	// A random angular velocity modifier for new particles.
	AUTO_PROP float rndAngularVelocity GetRndAngularVelocity SetRndAngularVelocity

	// Returns a copy of all particles and assigns an array of all particles to be the current particles.
	CUSTOM_PROP Particle[] particles
	{
		int size = self->GetParticleCount();
		ScriptingArrayPtr array = CreateScriptingArray<SimpleParticle> (GetScriptingManager().GetCommonClasses().particle, self->GetParticleCount());
		self->ReadParticles(Scripting::GetScriptingArrayStart<SimpleParticle>(array), 0, size);
		return array;
	}
	{
		self->WriteParticles(Scripting::GetScriptingArrayStart<SimpleParticle>(value), GetScriptingArraySize(value));
	}

	// The current number of particles (RO).
	AUTO_PROP int particleCount GetParticleCount

	// Removes all particles from the particle emitter.
	AUTO void ClearParticles();

	// Emit a number of particles.
	CSRAW public void Emit () { Emit2 ( (int)Random.Range (minEmission, maxEmission) ); }

	// Emit /count/ particles immediately

	CSRAW public void Emit (int count) { Emit2 (count);}

	// Emit a single particle with given parameters.
	CSRAW public void Emit (Vector3 pos, Vector3 velocity, float size, float energy, Color color)
	{
		InternalEmitParticleArguments args = new InternalEmitParticleArguments();
		args.pos = pos;
		args.velocity = velocity;
		args.size = size;
		args.energy = energy;
		args.color = color;
		args.rotation = 0;
		args.angularVelocity = 0;
		Emit3 (ref args);
	}
	//
	CSRAW public void Emit (Vector3 pos, Vector3 velocity, float size, float energy, Color color, float rotation, float angularVelocity)
	{
		InternalEmitParticleArguments args = new InternalEmitParticleArguments();
		args.pos = pos;
		args.velocity = velocity;
		args.size = size;
		args.energy = energy;
		args.color = color;
		args.rotation = rotation;
		args.angularVelocity = angularVelocity;
		Emit3 (ref args);
	}

	CUSTOM private void Emit2 (int count)
	{
		self->EmitResetEmitterPos (count, 0.0F);
	}

	CUSTOM private void Emit3 (ref InternalEmitParticleArguments args)
	{
		self->Emit (args.pos, args.velocity, args.size, args.energy, args.color, args.rotation, args.angularVelocity);
	}

	// Advance particle simulation by given time.
	CUSTOM void Simulate (float deltaTime)
	{
		self->UpdateParticleSystem(deltaTime);
	}

	// Turns the ParticleEmitter on or off.
	AUTO_PROP bool enabled GetEnabled SetEnabled
END


// (Legacy Particles) Particle animators move your particles over time, you use them to apply wind, drag & color cycling to your particle emitters.
CLASS ParticleAnimator : Component
	// Do particles cycle their color over their lifetime?
	AUTO_PROP bool doesAnimateColor GetDoesAnimateColor SetDoesAnimateColor

	// World space axis the particles rotate around.
	AUTO_PROP Vector3 worldRotationAxis GetWorldRotationAxis SetWorldRotationAxis

	// Local space axis the particles rotate around.
	AUTO_PROP Vector3 localRotationAxis GetLocalRotationAxis SetLocalRotationAxis

	// How the particle sizes grow over their lifetime.
	AUTO_PROP float sizeGrow GetSizeGrow SetSizeGrow

	// A random force added to particles every frame.
	AUTO_PROP Vector3 rndForce GetRndForce SetRndForce

	// The force being applied to particles every frame.
	AUTO_PROP Vector3 force GetForce SetForce

	// How much particles are slowed down every frame.
	AUTO_PROP float damping GetDamping SetDamping

	// Does the [[GameObject]] of this particle animator auto destructs?
	AUTO_PROP bool autodestruct GetAutodestruct SetAutodestruct

	// Colors the particles will cycle through over their lifetime.

	CUSTOM_PROP Color[] colorAnimation
	{
		ColorRGBAf col[ParticleAnimator::kColorKeys];
		self->GetColorAnimation(col);
		return CreateScriptingArray(col, ParticleAnimator::kColorKeys, GetScriptingManager().GetCommonClasses().color);
	}
	{
		Scripting::RaiseIfNull(value);
		if(GetScriptingArraySize(value) != ParticleAnimator::kColorKeys)
		{
			Scripting::RaiseMonoException(" Array needs to contain exactly 5 Colors for colorAnimation.");
			return;
		}
		self->SetColorAnimation(Scripting::GetScriptingArrayStart<ColorRGBAf> (value));
	}
END


// The trail renderer is used to make trails behind objects in the scene as they move about.
CLASS TrailRenderer : Renderer

	// How long does the trail take to fade out.
	AUTO_PROP float time GetTime SetTime

	// The width of the trail at the spawning point.
	AUTO_PROP float startWidth GetStartWidth SetStartWidth

	// The width of the trail at the end of the trail.
	AUTO_PROP float endWidth GetEndWidth SetEndWidth

	// Does the [[GameObject]] of this trail renderer auto destructs?
	AUTO_PROP bool autodestruct GetAutodestruct SetAutodestruct

END



// The rendering mode for legacy particles.
ENUM ParticleRenderMode
	// Render the particles as billboards facing the player. (Default)
	Billboard = 0,
	// Stretch particles in the direction of motion.
	Stretch = 3,
	// Sort the particles back-to-front and render as billboards.
	SortedBillboard = 2,
	// Render the particles as billboards always facing up along the y-Axis.
	HorizontalBillboard = 4,
	// Render the particles as billboards always facing the player, but not pitching along the x-Axis.
	VerticalBillboard = 5
END

// (Legacy Particles) Renders particles on to the screen.
CLASS ParticleRenderer : Renderer
	//  How particles are drawn.
	AUTO_PROP ParticleRenderMode particleRenderMode GetRenderMode SetRenderMode

	// How much are the particles stretched in their direction of motion.
	AUTO_PROP float lengthScale GetLengthScale SetLengthScale

	// How much are the particles strectched depending on "how fast they move"
	AUTO_PROP float velocityScale GetVelocityScale SetVelocityScale

	// How much are the particles strected depending on the [[Camera]]'s speed.
	AUTO_PROP float cameraVelocityScale GetCameraVelocityScale SetCameraVelocityScale

	// Clamp the maximum particle size.
	AUTO_PROP float maxParticleSize GetMaxParticleSize SetMaxParticleSize

	// Set horizontal tiling count.
	AUTO_PROP int uvAnimationXTile GetUVAnimationXTile SetUVAnimationXTile
	// Set vertical tiling count.
	AUTO_PROP int uvAnimationYTile GetUVAnimationYTile SetUVAnimationYTile

	// Set uv animation cycles
	AUTO_PROP float uvAnimationCycles GetUVAnimationCycles SetUVAnimationCycles

	OBSOLETE warning animatedTextureCount has been replaced by uvAnimationXTile and uvAnimationYTile.
	CSRAW public int animatedTextureCount { get { return uvAnimationXTile; } set { uvAnimationXTile = value; }	}

	//*undocumented fixed typo
	CSRAW public float maxPartileSize { get { return maxParticleSize; } set { maxParticleSize = value; } }

	//*undocumented UV Rect access
	CUSTOM_PROP Rect[] uvTiles { return CreateScriptingArray(self->GetUVFrames(), self->GetNumUVFrames(), GetScriptingManager().GetCommonClasses().rect); } { Scripting::RaiseIfNull(value); self->SetUVFrames(Scripting::GetScriptingArrayStart<Rectf> (value), GetScriptingArraySize(value)); }

CSRAW #if ENABLE_MONO
	OBSOLETE error This function has been removed.
	CSRAW public AnimationCurve widthCurve { get { return null; } set { } }

	OBSOLETE error This function has been removed.
	CSRAW public AnimationCurve heightCurve { get { return null; } set { } }

	OBSOLETE error This function has been removed.
	CSRAW public AnimationCurve rotationCurve { get { return null; } set { } }

CSRAW #endif
END


// The line renderer is used to draw free-floating lines in 3D space.
CLASS LineRenderer : Renderer
	// Set the line width at the start and at the end.
	AUTO void SetWidth(float start, float end);

	// Set the line color at the start and at the end.
	AUTO void SetColors(Color start, Color end);

	// Set the number of line segments.
	AUTO void SetVertexCount(int count);

	// Set the position of the vertex in the line.
	AUTO void SetPosition(int index, Vector3 position);

	// If enabled, the lines are defined in world space.
	AUTO_PROP bool useWorldSpace GetUseWorldSpace SetUseWorldSpace

END



// A block of material values to apply.
CLASS MaterialPropertyBlock
	// Just wraps a pointer to native property block object
	CSRAW internal IntPtr m_Ptr;

	//*undocumented*
	CUSTOM internal void InitBlock()
	{
		MonoMaterialPropertyBlock* block = new MonoMaterialPropertyBlock();
		self.SetPtr(block, MonoMaterialPropertyBlock::CleanupMonoMaterialPropertyBlock);
	}
	//*undocumented*
	THREAD_SAFE
	CUSTOM internal void DestroyBlock()
	{
		MonoMaterialPropertyBlock::CleanupMonoMaterialPropertyBlock((MonoMaterialPropertyBlock*)self.GetPtr());
	}

	//*undocumented*
	CSRAW public MaterialPropertyBlock()	{ InitBlock(); }
	CSRAW ~MaterialPropertyBlock()			{ DestroyBlock(); }

	///*listonly*
	CSRAW public void AddFloat (string name, float value)
	{
		AddFloat( Shader.PropertyToID(name), value );
	}
	// Add a float material property.
	CUSTOM void AddFloat (int nameID, float value)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		self->AddProperty( name, &value, 1, 1, 1 );
	}

	///*listonly*
	CSRAW public void AddVector (string name, Vector4 value) { AddVector( Shader.PropertyToID(name), value ); }
	// Add a vector material property.
	CUSTOM void AddVector (int nameID, Vector4 value)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
#if ENABLE_MONO
		self->AddProperty( name, value.GetPtr(), 1, 4, 1 );
#endif
	}

	///*listonly*
	CSRAW public void AddColor (string name, Color value)
	{
		AddColor( Shader.PropertyToID(name), value );
	}
	// Add a color material property.
	CUSTOM void AddColor (int nameID, Color value)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
#if ENABLE_MONO
		self->AddPropertyColor( name, value );
#endif
	}

	///*listonly*
	CSRAW public void AddMatrix (string name, Matrix4x4 value) { AddMatrix( Shader.PropertyToID(name), value ); }
	// Add a matrix material property.
	CUSTOM void AddMatrix (int nameID, Matrix4x4 value)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
#if ENABLE_MONO
		self->AddProperty( name, value.GetPtr(), 4, 4, 1 );
#endif
	}

	///*listonly*
	CSRAW public void AddTexture (string name, Texture value)
	{
		AddTexture (Shader.PropertyToID(name), value);
	}
	CUSTOM void AddTexture (int nameID, Texture value)
	{
		Texture* tex = value;
		if (!tex)
		{
			ErrorString ("Invalid argument for AddTexture()");
			return;
		}
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		self->AddPropertyTexture (name, tex->GetDimension(), tex->GetTextureID());
	}

	CSRAW public float GetFloat (string name) { return GetFloat (Shader.PropertyToID(name)); }
	CUSTOM float GetFloat (int nameID)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		const float* v = self->FindFloat (name);
		return v ? *v : 0.0f;
	}

	CSRAW public Vector4 GetVector (string name) { return GetVector (Shader.PropertyToID(name)); }
	CUSTOM Vector4 GetVector (int nameID)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		const Vector4f* v = self->FindVector (name);
		return v ? *v : Vector4f(0,0,0,0);
	}

	CSRAW public Matrix4x4 GetMatrix (string name) { return GetMatrix (Shader.PropertyToID(name)); }
	CUSTOM Matrix4x4 GetMatrix (int nameID)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		const Matrix4x4f* v = self->FindMatrix (name);
		return v ? *v : Matrix4x4f::identity;
	}

	CSRAW public Texture GetTexture (string name) { return GetTexture (Shader.PropertyToID(name)); }
	CUSTOM Texture GetTexture (int nameID)
	{
		ShaderLab::FastPropertyName name;
		name.index = nameID;
		TextureID v = self->FindTexture (name);
		if (v.m_ID == 0)
			return SCRIPTING_NULL;
		Texture* tex = Texture::FindTextureByID (v);
		return Scripting::ScriptingWrapperFor (tex);
	}

	// Clear material property values.
	CUSTOM void Clear() {
#if ENABLE_MONO
		self->Clear();
#endif
	}

END


// Color or depth buffer part of a [[RenderTexture]].
STRUCT RenderBuffer
	CSRAW internal int m_RenderTextureInstanceID;
	CSRAW internal IntPtr m_BufferPtr;
END

// Simple struct that contains all the arguments needed by the internal DrawTexture.
STRUCT internal InternalDrawTextureArguments
	CSRAW public Rect screenRect;
	#if UNITY_WINRT
	CSRAW public int textureInstanceId;
	#else
	CSRAW public Texture texture;
	#endif
	CSRAW public Rect sourceRect;
	CSRAW public int leftBorder;
	CSRAW public int rightBorder;
	CSRAW public int topBorder;
	CSRAW public int bottomBorder;
	CSRAW public Color32 color;
	#if UNITY_WINRT
	CSRAW public int matInstanceId;
	#else
	CSRAW public Material mat;
	#endif
END

C++RAW

struct MonoInternalDrawTextureArguments {
	Rectf screenRect;
	#if UNITY_WINRT
	int				   textureInstanceId;
	#else
	ScriptingObjectOfType<Texture> texture;
	#endif
	Rectf sourceRect;
	int leftBorder;
	int rightBorder;
	int topBorder;
	int bottomBorder;
	ColorRGBA32 color;
	#if UNITY_WINRT
	int					matInstanceId;
	#else
	ScriptingObjectOfType<Material> mat;
	#endif
};

// Simple struct that contains the arguments needed by Internal_DrawMeshTR.
STRUCT internal Internal_DrawMeshTRArguments
	CSRAW public int layer;
	CSRAW public int submeshIndex;
	CSRAW public Quaternion rotation;
	CSRAW public Vector3 position;
	CSRAW public int castShadows;
	CSRAW public int receiveShadows;
END

C++RAW

struct MonoInternal_DrawMeshTRArguments {
	int layer;
	int submeshIndex;
	Quaternionf rotation;
	Vector3f position;
	int castShadows;
	int receiveShadows;
};

// Simple struct that contains all the arguments needed by Internal_DrawMeshMatrix.
STRUCT internal Internal_DrawMeshMatrixArguments
	CSRAW public int layer;
	CSRAW public int submeshIndex;
	CSRAW public Matrix4x4 matrix;
	CSRAW public int castShadows;
	CSRAW public int receiveShadows;
END

C++RAW

struct MonoInternal_DrawMeshMatrixArguments {
	int layer;
	int submeshIndex;
	Matrix4x4f matrix;
	int castShadows;
	int receiveShadows;
};

// Raw interface to Unity's drawing functions.
CLASS Graphics

	/// *listonly*
	CSRAW static public void DrawMesh (Mesh mesh, Vector3 position, Quaternion rotation, Material material, int layer, Camera camera = null, int submeshIndex = 0, MaterialPropertyBlock properties = null) {
		Internal_DrawMeshTRArguments arguments = new Internal_DrawMeshTRArguments ();
		arguments.position = position;
		arguments.rotation = rotation;
		arguments.layer =  layer;
		arguments.submeshIndex = submeshIndex;
		arguments.castShadows = 1;
		arguments.receiveShadows = 1;
		Internal_DrawMeshTR(ref arguments, properties, material, mesh, camera);
	}
	// Draw a mesh.
	CSRAW static public void DrawMesh (Mesh mesh, Matrix4x4 matrix, Material material, int layer, Camera camera = null, int submeshIndex = 0, MaterialPropertyBlock properties = null) {
		Internal_DrawMeshMatrixArguments arguments = new Internal_DrawMeshMatrixArguments ();
		arguments.matrix = matrix;
		arguments.layer =  layer;
		arguments.submeshIndex = submeshIndex;
		arguments.castShadows = 1;
		arguments.receiveShadows = 1;

		Internal_DrawMeshMatrix(ref arguments, properties, material, mesh, camera);
	}
	//*undocumented*
	CSRAW static public void DrawMesh (Mesh mesh, Vector3 position, Quaternion rotation, Material material, int layer, Camera camera, int submeshIndex, MaterialPropertyBlock properties, bool castShadows, bool receiveShadows) {
		Internal_DrawMeshTRArguments arguments = new Internal_DrawMeshTRArguments ();
		arguments.position = position;
		arguments.rotation = rotation;
		arguments.layer =  layer;
		arguments.submeshIndex = submeshIndex;
		arguments.castShadows = castShadows ? 1 : 0;
		arguments.receiveShadows = receiveShadows ? 1 : 0;

		Internal_DrawMeshTR(ref arguments, properties, material, mesh, camera);
	}
	//*undocumented*
	CSRAW static public void DrawMesh (Mesh mesh, Matrix4x4 matrix, Material material, int layer, Camera camera, int submeshIndex, MaterialPropertyBlock properties, bool castShadows, bool receiveShadows) {
		Internal_DrawMeshMatrixArguments arguments = new Internal_DrawMeshMatrixArguments ();
		arguments.matrix = matrix;
		arguments.layer =  layer;
		arguments.submeshIndex = submeshIndex;
		arguments.castShadows = castShadows ? 1 : 0;
		arguments.receiveShadows = receiveShadows ? 1 : 0;

		Internal_DrawMeshMatrix(ref arguments, properties, material, mesh, camera);
	}
	CUSTOM private static void Internal_DrawMeshTR (ref Internal_DrawMeshTRArguments arguments,  MaterialPropertyBlock properties, Material material, Mesh mesh, Camera camera) {
		Camera* cameraPointer = camera;
		Matrix4x4f matrix;
		matrix.SetTR( arguments.position, arguments.rotation );

		IntermediateRenderer* r = AddMeshIntermediateRenderer( matrix, mesh, material, arguments.layer, arguments.castShadows != 0, arguments.receiveShadows != 0, arguments.submeshIndex, cameraPointer );
		MaterialPropertyBlock* propertiesPtr = properties.GetPtr();
		if (propertiesPtr)
			r->SetPropertyBlock (*propertiesPtr);
	}
	CUSTOM private static void Internal_DrawMeshMatrix (ref Internal_DrawMeshMatrixArguments arguments, MaterialPropertyBlock properties, Material material, Mesh mesh, Camera camera) {
		Camera* cameraPointer = camera;
		IntermediateRenderer* r = AddMeshIntermediateRenderer( arguments.matrix, mesh, material, arguments.layer, arguments.castShadows != 0, arguments.receiveShadows != 0, arguments.submeshIndex, cameraPointer);

		MaterialPropertyBlock* propertiesPtr = properties.GetPtr();
		if (propertiesPtr)
			r->SetPropertyBlock (*propertiesPtr);
	}

	/// *listonly*
	CSRAW static public void DrawMeshNow (Mesh mesh, Vector3 position, Quaternion rotation) { Internal_DrawMeshNow1(mesh, position, rotation, -1); }
	/// *listonly*
	CSRAW static public void DrawMeshNow (Mesh mesh, Vector3 position, Quaternion rotation, int materialIndex) { Internal_DrawMeshNow1(mesh, position, rotation, materialIndex); }
	/// *listonly*
	CSRAW static public void DrawMeshNow (Mesh mesh, Matrix4x4 matrix) { Internal_DrawMeshNow2(mesh, matrix, -1); }

	// Draw a mesh immediately.
	CSRAW static public void DrawMeshNow (Mesh mesh, Matrix4x4 matrix, int materialIndex) { Internal_DrawMeshNow2(mesh, matrix, materialIndex); }

	CUSTOM private static void Internal_DrawMeshNow1 (Mesh mesh, Vector3 position, Quaternion rotation, int materialIndex) {
		Shader* shader = s_ScriptingCurrentShader;
		if (!shader) {
			ErrorString ("DrawMesh requires material.SetPass before!");
			return;
		}
		DrawUtil::DrawMesh (*s_ScriptingCurrentChannels, *mesh, position, rotation);
	}
	CUSTOM private static void Internal_DrawMeshNow2 (Mesh mesh, Matrix4x4 matrix, int materialIndex) {
		Shader* shader = s_ScriptingCurrentShader;
		if (!shader) {
			ErrorString ("DrawMesh requires material.SetPass before!");
			return;
		}
		DrawUtil::DrawMesh (*s_ScriptingCurrentChannels, *mesh, matrix, materialIndex);
	}


	// Draws a fully procedural geometry on the GPU.
	CUSTOM static public void DrawProcedural (MeshTopology topology, int vertexCount, int instanceCount = 1) {
		DrawUtil::DrawProcedural (topology, vertexCount, instanceCount);
	}

	// Draws a fully procedural geometry on the GPU.
	CONDITIONAL !UNITY_FLASH
	CUSTOM static public void DrawProceduralIndirect (MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset = 0) {
		DrawUtil::DrawProceduralIndirect (topology, bufferWithArgs.GetPtr(), argsOffset);
	}


	CONDITIONAL UNITY_EDITOR
	CUSTOM static internal void DrawSprite (Sprite sprite, Matrix4x4 matrix, Material material, int layer, Camera camera, Color color, MaterialPropertyBlock properties)
	{
		Camera* cameraPointer = camera;
		IntermediateRenderer* r = AddSpriteIntermediateRenderer(matrix, sprite, material, layer, color, cameraPointer);

		MaterialPropertyBlock* propertiesPtr = properties.GetPtr();
		if (propertiesPtr)
			r->SetPropertyBlock (*propertiesPtr);
	}



	FLUSHCONDITIONS

	OBSOLETE warning Use Graphics.DrawMeshNow instead.
	CSRAW static public void DrawMesh (Mesh mesh, Vector3 position, Quaternion rotation) { Internal_DrawMeshNow1(mesh, position, rotation, -1); }
	OBSOLETE warning Use Graphics.DrawMeshNow instead.
	CSRAW static public void DrawMesh (Mesh mesh, Vector3 position, Quaternion rotation, int materialIndex) { Internal_DrawMeshNow1(mesh, position, rotation, materialIndex); }
	OBSOLETE warning Use Graphics.DrawMeshNow instead.
	CSRAW static public void DrawMesh (Mesh mesh, Matrix4x4 matrix) { Internal_DrawMeshNow2(mesh, matrix, -1); }
	OBSOLETE warning Use Graphics.DrawMeshNow instead.
	CSRAW static public void DrawMesh (Mesh mesh, Matrix4x4 matrix, int materialIndex) { Internal_DrawMeshNow2(mesh, matrix, materialIndex); }


	///*listonly*
	CSRAW public static void DrawTexture (Rect screenRect, Texture texture, Material mat = null) {
		DrawTexture (screenRect, texture, 0,0,0,0, mat);
	}
	///*listonly*
	CSRAW public static void DrawTexture (Rect screenRect, Texture texture, int leftBorder, int rightBorder, int topBorder, int bottomBorder, Material mat = null) {
		DrawTexture (screenRect, texture, new Rect (0,0,1,1), leftBorder, rightBorder, topBorder, bottomBorder, mat);
	}
	///*listonly*
	CSRAW public static void DrawTexture (Rect screenRect, Texture texture, Rect sourceRect, int leftBorder, int rightBorder, int topBorder, int bottomBorder, Material mat = null) {
		InternalDrawTextureArguments arguments = new InternalDrawTextureArguments ();
			arguments.screenRect = screenRect;
			#if UNITY_WINRT
			arguments.textureInstanceId = texture != null ? texture.GetInstanceID() : 0;
			#else
			arguments.texture = texture;
			#endif
			arguments.sourceRect = sourceRect;
			arguments.leftBorder = leftBorder;
			arguments.rightBorder = rightBorder;
			arguments.topBorder = topBorder;
			arguments.bottomBorder = bottomBorder;
			Color32 c = new Color32();
			c.r = c.g = c.b = c.a = 128;
			arguments.color = c;
			#if UNITY_WINRT
			arguments.matInstanceId = mat != null ? mat.GetInstanceID() : 0;
			#else
			arguments.mat = mat;
			#endif
		DrawTexture (ref arguments);
	}
	// Draw a texture in screen coordinates.
	CSRAW public static void DrawTexture (Rect screenRect, Texture texture, Rect sourceRect, int leftBorder, int rightBorder, int topBorder, int bottomBorder, Color color, Material mat = null) {
		InternalDrawTextureArguments arguments = new InternalDrawTextureArguments ();
			arguments.screenRect = screenRect;
			#if UNITY_WINRT
			arguments.textureInstanceId = texture != null ? texture.GetInstanceID() : 0;
			#else
			arguments.texture = texture;
			#endif
			arguments.sourceRect = sourceRect;
			arguments.leftBorder = leftBorder;
			arguments.rightBorder = rightBorder;
			arguments.topBorder = topBorder;
			arguments.bottomBorder = bottomBorder;
			arguments.color = color;
			#if UNITY_WINRT
			arguments.matInstanceId = mat != null ? mat.GetInstanceID() : 0;
			#else
			arguments.mat = mat;
			#endif
		DrawTexture (ref arguments);
	}

	CUSTOM internal static void DrawTexture (ref InternalDrawTextureArguments arguments) {
	#if UNITY_WINRT
		DrawGUITexture (
			arguments.screenRect,
			PPtr<Texture>(arguments.textureInstanceId),
			arguments.sourceRect,
			arguments.leftBorder,
			arguments.rightBorder,
			arguments.topBorder,
			arguments.bottomBorder,
			ColorRGBA32(arguments.color),
			PPtr<Material>(arguments.matInstanceId));
	#else
		DrawGUITexture (arguments.screenRect, arguments.texture, arguments.sourceRect, arguments.leftBorder, arguments.rightBorder, arguments.topBorder, arguments.bottomBorder, ColorRGBA32(arguments.color), arguments.mat);
	#endif
	}

	/// *listonly*
	CUSTOM static void Blit (Texture source, RenderTexture dest)
	{
		ImageFilters::Blit (source, dest);
	}

	// Copies source texture into destination render texture.
	CSRAW public static void Blit (Texture source, RenderTexture dest, Material mat, int pass = -1)
	{
		Internal_BlitMaterial (source, dest, mat, pass, true);
	}

	CSRAW public static void Blit (Texture source, Material mat, int pass = -1)
	{
		Internal_BlitMaterial (source, null, mat, pass, false);
	}

	CUSTOM private static void Internal_BlitMaterial (Texture source, RenderTexture dest, Material mat, int pass, bool setRT)
	{
		Material* m = mat;
		if (m == NULL)
		{
			ErrorString ("Graphics.Blit: material is null");
			return;
		}
		ImageFilters::Blit (source, dest, m, pass, setRT);
	}

	// Copies source texture into destination, for multi-tap shader.
	CSRAW public static void BlitMultiTap (Texture source, RenderTexture dest, Material mat, params Vector2[] offsets)
	{
		Internal_BlitMultiTap (source, dest, mat, offsets);
	}

	CUSTOM private static void Internal_BlitMultiTap (Texture source, RenderTexture dest, Material mat, Vector2[] offsets)
	{
		Material* m = mat;
		if (m == NULL)
		{
			ErrorString ("Graphics.BlitMultiTap: material is null");
			return;
		}
		int size = GetScriptingArraySize (offsets);
		const Vector2f* arr = Scripting::GetScriptingArrayStart<Vector2f> (offsets);
		ImageFilters::BlitMultiTap (source, dest, m, size, arr);
	}


	CSRAW public static void SetRenderTarget (RenderTexture rt) {
		Internal_SetRT (rt, 0, -1);
	}
	CSRAW public static void SetRenderTarget (RenderTexture rt, int mipLevel) {
		Internal_SetRT (rt, mipLevel, -1);
	}
	CSRAW public static void SetRenderTarget (RenderTexture rt, int mipLevel, CubemapFace face) {
		Internal_SetRT (rt, mipLevel, (int)face);
	}

	///*listonly*
	CSRAW public static void SetRenderTarget (RenderBuffer colorBuffer, RenderBuffer depthBuffer) {
		Internal_SetRTBuffer (out colorBuffer, out depthBuffer);
	}

	// Sets current render target.
	CSRAW public static void SetRenderTarget (RenderBuffer[] colorBuffers, RenderBuffer depthBuffer) {
		Internal_SetRTBuffers (colorBuffers, out depthBuffer);
	}

	CUSTOM private static void Internal_SetRT (RenderTexture rt, int mipLevel, int face) {
		RenderTexture::SetActive (rt, mipLevel, (CubemapFace)face);
	}

	CUSTOM private static void Internal_SetRTBuffer (out RenderBuffer colorBuffer, out RenderBuffer depthBuffer) {
		RenderTexture* rtC = PPtr<RenderTexture>(colorBuffer->m_RenderTextureInstanceID);
		RenderTexture* rtD = PPtr<RenderTexture>(depthBuffer->m_RenderTextureInstanceID);
		if (rtC && !rtD)
		{
			ErrorString ("SetRenderTarget can only mix color & depth buffers from RenderTextures. You're trying to set depth buffer from the screen.");
			return;
		}
		if (!rtC && rtD)
		{
			ErrorString ("SetRenderTarget can only mix color & depth buffers from RenderTextures. You're trying to set color buffer from the screen.");
			return;
		}
		if (rtC)
		{
			RenderSurfaceHandle rsHandle(colorBuffer->m_BufferPtr);
			RenderTexture::SetActive (1, &rsHandle, RenderSurfaceHandle(depthBuffer->m_BufferPtr), rtC);
		}
		else
		{
			RenderTexture::SetActive (NULL);
		}
	}

	CUSTOM private static void Internal_SetRTBuffers (RenderBuffer[] colorBuffers, out RenderBuffer depthBuffer) {
		int size = GetScriptingArraySize (colorBuffers);
		if (size < 1 || size > kMaxSupportedRenderTargets)
		{
			ErrorString ("Invalid color buffer count for SetRenderTarget");
			return;
		}

		const ScriptingRenderBuffer* arr = Scripting::GetScriptingArrayStart<ScriptingRenderBuffer> (colorBuffers);
		RenderTexture* rtC = PPtr<RenderTexture>(arr[0].m_RenderTextureInstanceID);
		RenderTexture* rtD = PPtr<RenderTexture>(depthBuffer->m_RenderTextureInstanceID);
		if (rtC && !rtD)
		{
			ErrorString ("SetRenderTarget can only mix color & depth buffers from RenderTextures. You're trying to set depth buffer from the screen.");
			return;
		}
		if (!rtC && rtD)
		{
			ErrorString ("SetRenderTarget can only mix color & depth buffers from RenderTextures. You're trying to set color buffer from the screen.");
			return;
		}
		if (rtC)
		{
			RenderSurfaceHandle colorHandles[kMaxSupportedRenderTargets];
			for (int i = 0; i < size; ++i)
				colorHandles[i].object = arr[i].m_BufferPtr;
			RenderTexture::SetActive (size, colorHandles, RenderSurfaceHandle(depthBuffer->m_BufferPtr), rtC);
		}
		else
		{
			RenderTexture::SetActive (NULL);
		}
	}

	// Currently active color buffer (RO).
	CSRAW public static RenderBuffer activeColorBuffer { get { RenderBuffer res; GetActiveColorBuffer (out res); return res; } }

	// Currently active depth buffer (RO).
	CSRAW public static RenderBuffer activeDepthBuffer { get { RenderBuffer res; GetActiveDepthBuffer (out res); return res; } }

	CUSTOM private static void GetActiveColorBuffer (out RenderBuffer res) {
		GfxDevice& device = GetGfxDevice();
		RenderTexture* rt = device.GetActiveRenderTexture();
		res->m_RenderTextureInstanceID = rt ? rt->GetInstanceID() : 0;
		res->m_BufferPtr = rt ? device.GetActiveRenderColorSurface(0).object : NULL;
	}
	CUSTOM private static void GetActiveDepthBuffer (out RenderBuffer res) {
		GfxDevice& device = GetGfxDevice();
		RenderTexture* rt = device.GetActiveRenderTexture();
		res->m_RenderTextureInstanceID = rt ? rt->GetInstanceID() : 0;
		res->m_BufferPtr = rt ? device.GetActiveRenderDepthSurface().object : NULL;
	}

	CSRAW public static void SetRandomWriteTarget (int index, RenderTexture uav) {
		Internal_SetRandomWriteTargetRT (index, uav);
	}

	CONDITIONAL !UNITY_FLASH
	CSRAW public static void SetRandomWriteTarget (int index, ComputeBuffer uav) {
		Internal_SetRandomWriteTargetBuffer (index, uav);
	}
	CUSTOM public static void ClearRandomWriteTargets () {
		GetGfxDevice().ClearRandomWriteTargets();
	}

	CUSTOM private static void Internal_SetRandomWriteTargetRT (int index, RenderTexture uav) {
		RenderTexture* rt = uav;
		TextureID tid = rt ? rt->GetTextureID() : TextureID();
		GetGfxDevice().SetRandomWriteTargetTexture(index, tid);
	}

	CONDITIONAL !UNITY_FLASH
	CUSTOM private static void Internal_SetRandomWriteTargetBuffer (int index, ComputeBuffer uav) {
		GetGfxDevice().SetRandomWriteTargetBuffer(index, uav->GetBufferHandle());
	}

	FLUSHCONDITIONS

	OBSOLETE warning Use SystemInfo.graphicsDeviceName instead.
	CSRAW static public string deviceName { get { return SystemInfo.graphicsDeviceName; } }

	OBSOLETE warning Use SystemInfo.graphicsDeviceVendor instead.
	CSRAW static public string deviceVendor { get { return SystemInfo.graphicsDeviceVendor; } }

	OBSOLETE warning Use SystemInfo.graphicsDeviceVersion instead.
	CSRAW static public string deviceVersion { get { return SystemInfo.graphicsDeviceVersion; } }

	OBSOLETE warning Use SystemInfo.supportsVertexPrograms instead.
	CSRAW static public bool supportsVertexProgram { get { return SystemInfo.supportsVertexPrograms; } }

	//*undocumented*
	CUSTOM internal static void SetupVertexLights (Light[] lights)
	{
		const int size = GetScriptingArraySize(lights);
		std::vector<Light*> lightsVec(size);
		for (int i = 0; i < size; ++i)
			lightsVec[i] = ScriptingObjectToObject<Light>(Scripting::GetScriptingArrayElementNoRef<ScriptingObjectPtr> (lights, i));

		SetupVertexLights(lightsVec);
	}

END



// Represents a display resolution.
STRUCT Resolution
	// Keep in sync with ScreenManager::Resolution
	CSRAW private int m_Width;
	CSRAW private int m_Height;
	CSRAW private int m_RefreshRate;

	// Resolution width in pixels.
	CSRAW public int width { get { return m_Width; } set { m_Width = value; } }
	// Resolution height in pixels.
	CSRAW public int height { get { return m_Height; } set { m_Height = value; } }
	// Resolution's vertical refresh rate in Hz.
	CSRAW public int refreshRate { get { return m_RefreshRate; } set { m_RefreshRate = value; } }
END



// Data of a lightmap.
CSRAW [StructLayout (LayoutKind.Sequential)]
CLASS LightmapData
	CSRAW internal Texture2D m_Lightmap;
	CSRAW internal Texture2D m_IndirectLightmap;

	// Lightmap storing the full incoming light.
	CSRAW public Texture2D lightmapFar { get { return m_Lightmap; } set { m_Lightmap = value; } }

	OBSOLETE warning Use lightmapFar instead
	CSRAW public Texture2D lightmap { get { return m_Lightmap; } set { m_Lightmap = value; } }

	// Lightmap storing only the indirect incoming light.
	CSRAW public Texture2D lightmapNear { get { return m_IndirectLightmap; } set { m_IndirectLightmap = value; } }
END

// Single, dual, or directional lightmaps rendering mode.
ENUM LightmapsMode
	// Single, traditional lightmap rendering mode.
	Single = 0,

	// Dual lightmap rendering mode.
	Dual = 1,

	// Directional rendering mode.
	Directional = 2,
END

// Valid color spaces
ENUM ColorSpace
	// Uninitialized colorspace
	Uninitialized = -1,

	// Lightmap has been baked for gamma rendering
	Gamma = 0,

	// Lightmap has been baked for linear rendering
	Linear = 1
END


// Stores light probes for the scene.
CONDITIONAL ENABLE_MONO || UNITY_WINRT
CLASS LightProbes : Object
	// Returns spherical harmonics coefficients of a light probe at the given position. The light probe is interpolated from the light probes baked
	CUSTOM void GetInterpolatedLightProbe(Vector3 position, Renderer renderer, float[] coefficients)
	{
		if (GetScriptingArraySize(coefficients) != kLightProbeBasisCount * 3)
			Scripting::RaiseArgumentException("Coefficients array must have 9*3 elements");

		self->GetInterpolatedLightProbe(position, renderer, &Scripting::GetScriptingArrayElement<float> (coefficients, 0));
	}

	// Positions of the baked light probes.
	CUSTOM_PROP Vector3[] positions
	{
		return CreateScriptingArray(self->GetPositions(), self->GetPositionsSize(), MONO_COMMON.vector3);
	}

	// Coefficients of the baked light probes. The coefficients represent a 3-band RGB spherical harmonics probe, with a total of 27 floats per light probe, laid out: rgbrgbrgb...

	CUSTOM_PROP float[] coefficients
	{
		return CreateScriptingArray(reinterpret_cast<float*>(self->GetCoefficients()), self->GetPositionsSize()*kLightProbeCoefficientCount, MONO_COMMON.floatSingle);
	}
	{
		if (GetScriptingArraySize(value) != self->GetPositionsSize() * kLightProbeBasisCount * 3)
			Scripting::RaiseArgumentException("Coefficients array must have probeCount*9*3 elements");

		self->SetCoefficients(&Scripting::GetScriptingArrayElement<float> (value, 0), GetScriptingArraySize(value));
	}

	// The number of light probes.
	CUSTOM_PROP int count
	{
		return self->GetPositionsSize();
	}

	// The number of cells (tetrahedra + outer cells) the space is divided to.
	CUSTOM_PROP int cellCount
	{
		return self->GetTetrahedraSize();
	}
END

// Stores lightmaps of the scene.
CONDITIONAL ENABLE_MONO || UNITY_WINRT
CLASS LightmapSettings : Object

	// Lightmap array.
	CUSTOM_PROP static LightmapData[] lightmaps
	{ return VectorToScriptingClassArray<LightmapData, LightmapDataMono> (GetLightmapSettings().GetLightmaps(), GetScriptingTypeRegistry().GetType("UnityEngine", "LightmapData"), LightmapDataToMono); }
	{ GetLightmapSettings().SetLightmaps (ScriptingClassArrayToVector<LightmapData, LightmapDataMono> (value, LightmapDataToCpp)); }

	// Single, Dual or Directional lightmaps rendering mode.
	CUSTOM_PROP static LightmapsMode lightmapsMode
	{ return  GetLightmapSettings().GetLightmapsMode (); }
	{ GetLightmapSettings().SetLightmapsMode (value); }

	// Color space of the lightmap
	CUSTOM_PROP static ColorSpace bakedColorSpace
	{ return  GetLightmapSettings().GetBakedColorSpace (); }
	{ }

	// Holds all data needed by the light probes.
	CUSTOM_PROP static LightProbes lightProbes
	{
		return Scripting::ScriptingWrapperFor(GetLightmapSettings().GetLightProbes());
	}
	{
		GetLightmapSettings().SetLightProbes(value);
	}
END

// Utility class for common geometric functions.
CLASS GeometryUtility

	// Calculates frustum planes.
	CSRAW static public Plane[] CalculateFrustumPlanes (Camera camera)
	{
		return CalculateFrustumPlanes (camera.projectionMatrix * camera.worldToCameraMatrix);
	}

	// Calculates frustum planes.
	CSRAW static public Plane[] CalculateFrustumPlanes (Matrix4x4 worldToProjectionMatrix)
	{
		Plane[] planes = new Plane[6];
		Internal_ExtractPlanes (planes, worldToProjectionMatrix);
		return planes;
	}

	CUSTOM private static void Internal_ExtractPlanes (Plane[] planes, Matrix4x4 worldToProjectionMatrix)
	{
		ExtractProjectionPlanes(worldToProjectionMatrix, Scripting::GetScriptingArrayStart<Plane> (planes));
	}


	// Returns true if bounds are inside the plane array.
	CUSTOM static bool TestPlanesAABB (Plane[] planes, Bounds bounds)
	{
		return TestPlanesAABB(Scripting::GetScriptingArrayStart<Plane> (planes), GetScriptingArraySize(planes), bounds);
	}
END


// Describes screen orientation.
ENUM ScreenOrientation
	//*undocumented*
	Unknown = 0,

	// Portrait orientation.
	Portrait = 1,

	// Portrait orientation, upside down.
	PortraitUpsideDown = 2,

	// Landscape orientation, counter-clockwise from the portrait orientation.
	LandscapeLeft = 3,

	// Landscape orientation, clockwise from the portrait orientation.
	LandscapeRight = 4,

	// Auto Rotation, will use enabled orientations.
	AutoRotation = 5,

	//*undocumented*
	Landscape = 3
END


// Access to display information.
CLASS Screen

	// All fullscreen resolutions supported by the monitor (RO).

	CUSTOM_PROP static Resolution[] resolutions
	{
		ScriptingClassPtr klass = GetScriptingManager ().GetCommonClasses ().resolution;
		ScreenManager::Resolutions resolutions = GetScreenManager ().GetResolutions ();
		ScriptingArrayPtr array = CreateScriptingArray<ScreenManager::Resolution> (klass, resolutions.size ());
		for (int i=0;i<resolutions.size ();i++)
			Scripting::SetScriptingArrayElement (array, i, resolutions[i]);

		return array;
	}

	OBSOLETE planned
	CSRAW static public Resolution[] GetResolution { get { return resolutions; } }

	// The current screen resolution (RO).
	CUSTOM_PROP static Resolution currentResolution { return GetScreenManager().GetCurrentResolution (); }

	// Switches the screen resolution.
	CUSTOM static void SetResolution (int width, int height, bool fullscreen, int preferredRefreshRate = 0)
	{
		#if WEBPLUG
		if (fullscreen)
		{
			if (!GetScreenManager ().GetAllowFullscreenSwitch())
			{
				ErrorString("Fullscreen mode can only be enabled in the web player after clicking on the content.");
				return;
			}
			// when going from windowed to fullscreen, show escape warning
			if( !GetScreenManager().IsFullScreen() )
				ShowFullscreenEscapeWarning();
		}
		#endif

		GetScreenManager ().RequestResolution (width, height, fullscreen, preferredRefreshRate);
	}

	// Should the cursor be visible?
	CUSTOM_PROP static bool showCursor { return GetScreenManager ().GetShowCursor (); }  { GetScreenManager ().SetShowCursor (value); }

	// Should the cursor be locked?
	CUSTOM_PROP static bool lockCursor { return GetScreenManager ().GetLockCursor (); }  { GetScreenManager ().SetLockCursor (value); }


	// The current width of the screen window in pixels (RO).
	THREAD_SAFE
	CUSTOM_PROP static int width { return GetScreenManager ().GetWidth (); }

	// The current height of the screen window in pixels (RO).
	THREAD_SAFE
	CUSTOM_PROP static int height { return GetScreenManager ().GetHeight (); }

	// The current DPI of the screen / device (RO).
	CUSTOM_PROP static float dpi { return GetScreenManager ().GetDPI (); }

	// Is the game running fullscreen?
	CUSTOM_PROP static bool fullScreen
	{
		return GetScreenManager ().IsFullScreen ();
	}
	{
		ScreenManager& screen = GetScreenManager();
		bool goFullscreen = (bool)value;
		if (goFullscreen  == screen.IsFullScreen ())
		{
			return;
		}

		#if WEBPLUG
		if (goFullscreen)
		{
			if (!GetScreenManager().GetAllowFullscreenSwitch())
			{
				ErrorString("Fullscreen mode can only be enabled in the web player after clicking on the content.");
				return;
			}
			// when going from windowed to fullscreen, show escape warning
			if( !screen.IsFullScreen() )
				ShowFullscreenEscapeWarning();
		}
		#endif

		screen.RequestSetFullscreen (goFullscreen);
	}

	// Allow auto-rotation to portrait?
	CUSTOM_PROP static bool autorotateToPortrait {
		return GetScreenManager().GetIsOrientationEnabled(kAutorotateToPortrait);
	} {
		GetScreenManager().SetIsOrientationEnabled(kAutorotateToPortrait, value);
	}

	// Allow auto-rotation to portrait, upside down?
	CUSTOM_PROP static bool autorotateToPortraitUpsideDown {
		return GetScreenManager().GetIsOrientationEnabled(kAutorotateToPortraitUpsideDown);
	} {
		GetScreenManager().SetIsOrientationEnabled(kAutorotateToPortraitUpsideDown, value);
	}

	// Allow auto-rotation to landscape left?
	CUSTOM_PROP static bool autorotateToLandscapeLeft {
		return GetScreenManager().GetIsOrientationEnabled(kAutorotateToLandscapeLeft);
	} {
		GetScreenManager().SetIsOrientationEnabled(kAutorotateToLandscapeLeft, value);
	}

	// Allow auto-rotation to landscape right?
	CUSTOM_PROP static bool autorotateToLandscapeRight {
		return GetScreenManager().GetIsOrientationEnabled(kAutorotateToLandscapeRight);
	} {
		GetScreenManager().SetIsOrientationEnabled(kAutorotateToLandscapeRight, value);
	}


	// Specifies logical orientation of the screen.
	CUSTOM_PROP static ScreenOrientation orientation {
		return GetScreenManager ().GetScreenOrientation ();
	} {
		GetScreenManager ().RequestOrientation (value);
	}

	// A power saving setting, allowing the screen to dim some time after the
	CUSTOM_PROP static int sleepTimeout {
		return GetScreenManager ().GetScreenTimeout ();
	} {
		GetScreenManager ().SetScreenTimeout (value);
	}
END

// Constants for special values of [[Screen.sleepTimeout]]. Use them to
CLASS SleepTimeout
	// Prevent screen dimming.
	CSRAW public const int NeverSleep = -1;

	// Set the sleep timeout to whatever user has specified in the system
	CSRAW public const int SystemSetting = -2;
END



// Low-level graphics library.
CLASS GL
	// Submit a vertex.
	CUSTOM static void Vertex3 (float x, float y, float z) { GetGfxDevice().ImmediateVertex( x,y,z ); }
	// Submit a vertex.
	CUSTOM static void Vertex (Vector3 v) { GetGfxDevice().ImmediateVertex( v.x, v.y, v.z ); }

	// Sets current vertex color.
	CUSTOM static void Color (Color c) { GetGfxDevice().ImmediateColor(c.r, c.g, c.b, c.a); }

	// Sets current texture coordinate (v.x,v.y,v.z) for all texture units.
	CUSTOM static void TexCoord (Vector3 v)  { GetGfxDevice().ImmediateTexCoordAll(v.x, v.y, v.z); }

	// Sets current texture coordinate (x,y) for all texture units.
	CUSTOM static void TexCoord2 (float x, float y) { GetGfxDevice().ImmediateTexCoordAll(x, y, 0.0f); }

	// Sets current texture coordinate (x,y,z) for all texture units.
	CUSTOM static void TexCoord3 (float x, float y, float z) { GetGfxDevice().ImmediateTexCoordAll(x, y, z); }

	// Sets current texture coordinate (x,y) for the actual texture /unit/.
	CUSTOM static void MultiTexCoord2 (int unit, float x, float y)
	{
		GetGfxDevice().ImmediateTexCoord( unit, x, y, 0.0f );
	}

	// Sets current texture coordinate (x,y,z) to the actual texture /unit/.
	CUSTOM static void MultiTexCoord3 (int unit, float x, float y, float z)
	{
		GetGfxDevice().ImmediateTexCoord( unit, x, y, z );
	}

	// Sets current texture coordinate (v.x,v.y,v.z) to the actual texture /unit/.
	CUSTOM static void MultiTexCoord (int unit, Vector3 v)
	{
		GetGfxDevice().ImmediateTexCoord( unit, v.x, v.y, v.z );
	}


	// Mode for ::ref::Begin: draw triangles.
	CSRAW public const int TRIANGLES = 0x0004;

	// Mode for ::ref::Begin: draw triangle strip.
	CSRAW public const int TRIANGLE_STRIP = 0x0005;

	// Mode for ::ref::Begin: draw quads.
	CSRAW public const int QUADS = 0x0007;

	// Mode for ::ref::Begin: draw lines.
	CSRAW public const int LINES = 0x0001;


	// Begin drawing 3D primitives.
	CUSTOM static void Begin (int mode) {
		GfxPrimitiveType pt;
		if( mode == 0x0004 )
			pt = kPrimitiveTriangles;
		else if( mode == 0x0005 )
			pt = kPrimitiveTriangleStripDeprecated;
		else if( mode == 0x0007 )
			pt = kPrimitiveQuads;
		else if( mode == 0x0001 )
			pt = kPrimitiveLines;
		else {
			Scripting::RaiseMonoException( "Invalid mode for GL.Begin" );
			return;
		}
		GetGfxDevice().ImmediateBegin( pt );
	}

	// End drawing 3D primitives.
	CUSTOM static void End () {
		GetGfxDevice().ImmediateEnd();
		GPU_TIMESTAMP();
	}

	// Helper function to set up an ortho perspective transform.
	CUSTOM static void LoadOrtho ()
	{
		LoadFullScreenOrthoMatrix();
	}

	// Setup a matrix for pixel-correct rendering.
	CUSTOM static void LoadPixelMatrix () {
		// Now the hack: regular code (GUITexts, GUITExtures etc.) needs to add the
		// vertical texel offset. However, looks like GUI code needs to subtract the
		// vertical texel offset. No idea why; I guess it's because GUI code does
		// the y-inversion by itself. So we pass true as the last parameter.
		if (GetCurrentCameraPtr() != NULL)
		{
			LoadPixelMatrix( GetCurrentCamera().GetScreenViewportRect(), GetGfxDevice(), true, true );
		}
	}

	// Do this "different name" trick because otherwise the wrapper functions for both
	// LoadPixelMatrix overloads will have the same name, making a compile error.
	CUSTOM private static void LoadPixelMatrixArgs(float left, float right, float bottom, float top)
	{
		// Now the hack: regular code (GUITexts, GUITExtures etc.) needs to add the
		// vertical texel offset. However, looks like GUI code needs to subtract the
		// vertical texel offset. No idea why; I guess it's because GUI code does
		// the y-inversion by itself. So we pass true as the last parameter.
		Rectf rect( left, bottom, right-left, top-bottom );
		LoadPixelMatrix( rect, GetGfxDevice(), true, true );
	}


	// Setup a matrix for pixel-correct rendering.
	CSRAW public static void LoadPixelMatrix (float left, float right, float bottom, float top)
	{
		LoadPixelMatrixArgs(left,right,bottom,top);
	}

	// Set the rendering viewport.
	CUSTOM static void Viewport (Rect pixelRect) {
		SetGLViewport(pixelRect);
	}

	// Load an arbitrary matrix to the current projection matrix.
	CUSTOM static void LoadProjectionMatrix (Matrix4x4 mat) {
		GetGfxDevice().SetProjectionMatrix (mat);
	}

	// Load the identity matrix to the current modelview matrix.
	CUSTOM static void LoadIdentity () {
		GetGfxDevice().SetViewMatrix (Matrix4x4f::identity.GetPtr()); // implicitly sets world to identity
	}

	// The current modelview matrix.
	CUSTOM_PROP static Matrix4x4 modelview
	{
		Matrix4x4f temp;
		GetGfxDevice().GetMatrix( temp.GetPtr() );
		return temp;
	}
	{
		GetGfxDevice().SetViewMatrix( value.GetPtr() );
	}

	// Multiplies the current modelview matrix with the one specified.
	CUSTOM static void MultMatrix (Matrix4x4 mat) {
		GetGfxDevice().SetWorldMatrix( mat.GetPtr() );
	}

	// Saves both projection and modelview matrices to the matrix stack.
	CUSTOM static void PushMatrix()
	{
		GfxDevice& dev = GetGfxDevice();
		g_ViewMatrixStack.Push(dev.GetViewMatrix());
		g_WorldMatrixStack.Push(dev.GetWorldMatrix());
		g_ProjectionMatrixStack.Push(dev.GetProjectionMatrix());
	}

	// Restores both projection and modelview matrices off the top of the matrix stack.
	CUSTOM static void PopMatrix ()
	{
		GfxDevice& dev = GetGfxDevice();
		g_WorldMatrixStack.Pop();
		g_ViewMatrixStack.Pop();
		g_ProjectionMatrixStack.Pop();
		// Setting the view matrix clears the world matrix to be compatible with GL the ways
		dev.SetViewMatrix(g_ViewMatrixStack.GetMatrix().GetPtr());
		dev.SetWorldMatrix(g_WorldMatrixStack.GetMatrix().GetPtr());
		dev.SetProjectionMatrix(g_ProjectionMatrixStack.GetMatrix());
	}


	// Compute GPU projection matrix from camera's projection matrix.
	CUSTOM static Matrix4x4 GetGPUProjectionMatrix (Matrix4x4 proj, bool renderIntoTexture)
	{
		bool openGLStyle = GetGfxDevice().UsesOpenGLTextureCoords();
		Matrix4x4f m = proj;
		CalculateDeviceProjectionMatrix (m, openGLStyle, !openGLStyle && renderIntoTexture);
		return m;
	}


	// Should rendering be done in wireframe?
	CUSTOM_PROP static bool wireframe { return GetGfxDevice().GetWireframe(); } { GetGfxDevice().SetWireframe(value);  }

	CUSTOM_PROP static bool sRGBWrite { return GetGfxDevice().GetSRGBWrite(); } { GetGfxDevice().SetSRGBWrite(value);  }

	// Select whether to invert the backface culling (true) or not (false).
	CUSTOM static void SetRevertBackfacing (bool revertBackFaces) { GetGfxDevice().SetUserBackfaceMode (revertBackFaces); }

	// Clear the current render buffer.
	CSRAW static public void Clear (bool clearDepth, bool clearColor, Color backgroundColor, float depth=1.0f) {
		Internal_Clear (clearDepth, clearColor, backgroundColor, depth);
	}

	CUSTOM static private void Internal_Clear (bool clearDepth, bool clearColor, Color backgroundColor, float depth) {
		UInt32 flags = 0;
		if (clearColor) flags |= kGfxClearColor;
		if (clearDepth) flags |= kGfxClearDepthStencil;
		GraphicsHelper::Clear (flags, backgroundColor.GetPtr(), depth, 0);
		GPU_TIMESTAMP();
	}


	// Clear the current render buffer with camera's skybox.
	CUSTOM static void ClearWithSkybox (bool clearDepth, Camera camera) {
		ClearWithSkybox(clearDepth, camera);
	}

	// Invalidate the internally cached renderstates.
	CUSTOM static void InvalidateState () {
		GL_CUSTOM_PushMatrix();
		GfxDevice& dev = GetGfxDevice();
		dev.InvalidateState();
		GL_CUSTOM_PopMatrix();
	}

	// Send a user-defined event to a native code plugin.
	CUSTOM static void IssuePluginEvent (int eventID)
	{
		GetGfxDevice().InsertCustomMarker (eventID);
	}

END


// GUI STUFF
// --------------------------------

// Base class for images & text strings displayed in a GUI.
NONSEALED_CLASS GUIElement : Behaviour

	// Is a point on screen inside the element.
	CUSTOM bool HitTest (Vector3 screenPosition, Camera camera = null) {
		return self->HitTest (Vector2f (screenPosition.x, screenPosition.y), GetCameraOrWindowRect(camera));
	}

	// Returns bounding rectangle of [[GUIElement]] in screen coordinates.
	CUSTOM Rect GetScreenRect (Camera camera = null) { return self->GetScreenRect (GetCameraOrWindowRect(camera)); }

END

// A texture image used in a 2D GUI.
CLASS GUITexture : GUIElement
	// The color of the GUI texture.
	AUTO_PROP Color color GetColor SetColor

	// The texture used for drawing.

	AUTO_PTR_PROP Texture texture GetTexture SetTexture

	// Pixel inset used for pixel adjustments for size and position.
	CUSTOM_PROP Rect pixelInset { return self->GetPixelInset(); } { self->SetPixelInset(value); }


	// The border defines the number of pixels from the edge that are not affected by scale.
	CUSTOM_PROP RectOffset border
	{
		RectOffset* rectOffset = new RectOffset ();

		rectOffset->left	= self->m_LeftBorder;
		rectOffset->right	= self->m_RightBorder;
		rectOffset->top		= self->m_TopBorder;
		rectOffset->bottom	= self->m_BottomBorder;

		ScriptingObjectWithIntPtrField<RectOffset> monoObject(scripting_object_new (MONO_COMMON.rectOffset));
		monoObject.SetPtr(rectOffset);
		return monoObject.object;
	}
	{
		self->m_LeftBorder		= value->left;
		self->m_RightBorder		= value->right;
		self->m_TopBorder		= value->top;
		self->m_BottomBorder	= value->bottom;
	}
END


// How multiline text should be aligned.
ENUM TextAlignment
	// Text lines are aligned on the left side.
	Left = 0,
	// Text lines are centered.
	Center = 1,
	// Text lines are aligned on the right side.
	Right = 2
END


// Where the anchor of the text is placed.
ENUM TextAnchor

	// Text is anchored in upper left corner.
	UpperLeft = 0,

	// Text is anchored in upper side, centered horizontally.
	UpperCenter = 1,

	// Text is anchored in upper right corner.
	UpperRight = 2,

	// Text is anchored in left side, centered vertically.
	MiddleLeft = 3,

	// Text is centered both horizontally and vertically.
	MiddleCenter = 4,

	// Text is anchored in right side, centered vertically.
	MiddleRight = 5,

	// Text is anchored in lower left corner.
	LowerLeft = 6,

	// Text is anchored in lower side, centered horizontally.
	LowerCenter = 7,

	// Text is anchored in lower right corner.
	LowerRight = 8

END


// A text string displayed in a GUI.
CLASS GUIText : GUIElement

	// The text to display.
	CUSTOM_PROP string text { return scripting_string_new (self->GetText ()); } { self->SetText (value); }

	// The [[Material]] to use for rendering.
	CUSTOM_PROP Material material
	{
		Material* material = self->GetMaterial ();
		if (material == NULL)
			material = GetBuiltinResource<Material> ("Font.mat");

		Material* instantiated = &Material::GetInstantiatedMaterial (material, *self, false);
		if (material != instantiated)
			self->SetMaterial (instantiated);

		return Scripting::ScriptingWrapperFor (instantiated);
	}
	{
		self->SetMaterial (value);
	}

	// Workaround for gcc/msvc where passing small mono structures by value does not work
	CUSTOM private void Internal_GetPixelOffset (out Vector2 output)
	{
		*output = self->GetPixelOffset();
	}
	CUSTOM private void Internal_SetPixelOffset (Vector2 p) { self->SetPixelOffset(p); }

	// The pixel offset of the text.
	CSRAW public Vector2 pixelOffset { get { Vector2 p; Internal_GetPixelOffset(out p); return p; } set { Internal_SetPixelOffset(value); }  }

	// The font used for the text.
	AUTO_PTR_PROP Font font GetFont SetFont

	// The alignment of the text.
	AUTO_PROP TextAlignment alignment GetAlignment SetAlignment

	// The anchor of the text.
	AUTO_PROP TextAnchor anchor GetAnchor SetAnchor

	// The line spacing multiplier.
	AUTO_PROP float lineSpacing GetLineSpacing SetLineSpacing

	// The tab width multiplier.
	AUTO_PROP float tabSize GetTabSize SetTabSize

	// The font size to use (for dynamic fonts)
	AUTO_PROP int fontSize GetFontSize SetFontSize

	// The font style to use (for dynamic fonts)
	AUTO_PROP FontStyle fontStyle GetFontStyle SetFontStyle

	// Enable HTML-style tags for Text Formatting Markup.
	AUTO_PROP bool richText GetRichText SetRichText

	// Color used to render the text
	AUTO_PROP Color color GetColor SetColor
END
// Info how to render a character from the font texture. See /Font.characterInfo/
STRUCT CharacterInfo
	CSRAW
	// Unicode value of the character
	public int index;
	// UV coordinates for the character in the texture
	public Rect	uv;
	// Screen coordinates for the character in generated text meshes
	public Rect	vert;
	// How for to advance between the beginning of this charcater and the next.
	public float width;
	// The size of the character or 0 if it is the default font size.
	public int size;
	// The style of the character.
	public FontStyle style;
	// Is the character flipped?
	public bool	flipped;
END

// Script interface for [[wiki:class-Font|font assets]].
CLASS Font : Object

	CUSTOM private static void Internal_CreateFont ([Writable]Font _font, string name)
	{
		Font* font = NEW_OBJECT (Font);
		SmartResetObject(*font);
		font->SetNameCpp (name);
		Scripting::ConnectScriptingWrapperToObject (_font.GetScriptingObject(), font);
	}

	// Creates a new font.
	CSRAW public Font () { Internal_CreateFont (this,null); }

	// Creates a new font named /name/.
	CSRAW public Font (string name){ Internal_CreateFont (this,name); }

	// The material used for the font display.
	AUTO_PTR_PROP Material material GetMaterial SetMaterial

	// Does this font have a specific character?
	CUSTOM bool HasCharacter (char c) { return self->HasCharacter((int)c);}

	// *undocumented*
	CONDITIONAL ENABLE_MONO || UNITY_WINRT
	CUSTOM_PROP string[] fontNames
	{
		ScriptingArrayPtr arr = CreateScriptingArray<ScriptingStringPtr>(MONO_COMMON.string, self->GetFontNames().size());
		int idx = 0;
		for (UNITY_VECTOR(kMemFont,UnityStr)::const_iterator i = self->GetFontNames().begin(); i != self->GetFontNames().end(); ++i)
		{
			Scripting::SetScriptingArrayElement<ScriptingStringPtr>(arr, idx, scripting_string_new(*i));
			idx++;
		}
		return arr;
	}
	{
		UNITY_VECTOR(kMemFont,UnityStr) names;
		for (int i = 0; i < GetScriptingArraySize(value); ++i)
			names.push_back(scripting_cpp_string_for(Scripting::GetScriptingArrayElementNoRef<ScriptingStringPtr>(value, i)));
		self->SetFontNames(names);
	}

	// Access an array of all characters contained in the font texture.
	CUSTOM_PROP public CharacterInfo[] characterInfo
	{
		const Font::CharacterInfos &infos = self->GetCharacterInfos();
		int size = infos.size();
		ScriptingArrayPtr array = CreateScriptingArray<ScriptingCharacterInfo> (GetScriptingManager().GetCommonClasses().characterInfo, size);
		#if UNITY_WINRT
			for (int i=0; i<size; i++)
			{
				ScriptingCharacterInfo temp; temp.CopyFrom(infos[i]);
				ScriptingObjectPtr data;
				MarshallNativeStructIntoManaged(temp, data);
				Scripting::SetScriptingArrayElement(array, i, data);
			}
		#else
			ScriptingCharacterInfo *sci = Scripting::GetScriptingArrayStart<ScriptingCharacterInfo>(array);
			for (int i=0; i<size; i++)
			{
				sci[i].CopyFrom(infos[i]);
			}
		#endif
		return array;
	}
	{
		Font::CharacterInfos infos;
		int size = GetScriptingArraySize(value);
		infos.resize(size);

		#if UNITY_WINRT
			for (int i=0; i<size; i++)
			{
				ScriptingCharacterInfo temp;
				MarshallManagedStructIntoNative(Scripting::GetScriptingArrayElementNoRef<ScriptingObjectPtr>(value, i), &temp);
				temp.CopyTo(infos[i]);
			}
		#else
			ScriptingCharacterInfo *sci = Scripting::GetScriptingArrayStart<ScriptingCharacterInfo>(value);
			for (int i=0; i<size; i++)
			{
				sci[i].CopyTo(infos[i]);
			}
		#endif
		self->SetCharacterInfos (infos);
	}

	// Request characters to be added to the font texture (dynamic fonts only).

	CUSTOM void RequestCharactersInTexture (string characters, int size = 0, FontStyle style = FontStyle.Normal)
	{
		UTF16String str(characters.AsUTF8().c_str());
		self->CacheFontForText (str.text, str.length, size, style);
	}

	// Callback delegate for use with ::ref::textureRebuildCallback.
	CSRAW public delegate void FontTextureRebuildCallback();
	CSRAW private event FontTextureRebuildCallback m_FontTextureRebuildCallback = null;

	CSRAW private void InvokeFontTextureRebuildCallback_Internal()
	{
		if (m_FontTextureRebuildCallback != null)
			m_FontTextureRebuildCallback();
	}

	// A delegate which gets called when the font texture is rebuilt (dynamic fonts only).
	CSRAW public FontTextureRebuildCallback textureRebuildCallback { get {
			return m_FontTextureRebuildCallback; }
		set { m_FontTextureRebuildCallback = value; }
	}

	// Get rendering info for a specific character
	CUSTOM bool GetCharacterInfo(char ch, out CharacterInfo info, int size = 0, FontStyle style = FontStyle.Normal)
	{
		if (self->HasCharacterInTexture (ch, size, style))
		{
			info->index = ch;
			info->size = size;
			info->style = style;
			self->GetCharacterRenderInfo( ch, size, style, info->vert, info->uv, info->flipped );
			info->width = self->GetCharacterWidth (ch, size, style);
			return true;
		}
		return false;
	}

END


// [[Component]] added to a camera to make it render 2D GUI elements.
CLASS GUILayer : Behaviour
	// Get the GUI element at a specific screen position.
	CUSTOM GUIElement HitTest (Vector3 screenPosition) { return Scripting::ScriptingWrapperFor (self->HitTest (Vector2f (screenPosition.x, screenPosition.y))); }
END

// Renders meshes inserted by the [[MeshFilter]] or [[TextMesh]].
CLASS MeshRenderer : Renderer
END

// StaticBatchingUtility can prepare your objects to take advantage of Unity's static batching.
CONDITIONAL !UNITY_FLASH
CLASS StaticBatchingUtility

	// Combine will prepare all children of the @@staticBatchRoot@@ for static batching.
	CSRAW static public void Combine (GameObject staticBatchRoot)
	{
		InternalStaticBatchingUtility.Combine(staticBatchRoot);
	}

	// Combine will prepare all @@gos@@ for the static batching. @@staticBatchRoot@@ will be treated as their parent.
	CSRAW static public void Combine (GameObject[] gos, GameObject staticBatchRoot)
	{
		InternalStaticBatchingUtility.Combine(gos, staticBatchRoot);
	}


	C++RAW

	struct InternalMonoMeshInstance
	{
		int					meshInstanceID;
		Matrix4x4f			transform;
		Vector4f			lightmapTilingOffset;
	};

	CUSTOM static internal Mesh InternalCombineVertices (MeshSubsetCombineUtility.MeshInstance[] meshes, string meshName)
	{
		const int numMeshes = GetScriptingArraySize( meshes );

		CombineInstances mi;

		mi.resize ( numMeshes );
		InternalMonoMeshInstance* instances = Scripting::GetScriptingArrayStart<InternalMonoMeshInstance>( meshes );
		for ( int i=0; i!=numMeshes; ++i )
		{
			mi[i].mesh = PPtr<Mesh>(instances[i].meshInstanceID);
			mi[i].transform = instances[i].transform;
			mi[i].lightmapTilingOffset = instances[i].lightmapTilingOffset;
		}

		Mesh* outMesh = CreateObjectFromCode<Mesh> (kDefaultAwakeFromLoad);

		CombineMeshVerticesForStaticBatching ( mi, meshName, *outMesh );

		return Scripting::ScriptingWrapperFor( outMesh );
	}

	C++RAW

	struct InternalMonoSubMeshInstance
	{
		int	meshInstanceID;		// public Mesh mesh;
		int vertexOffset;			// public int vertexOffset;
		int goInstanceID;	// public GameObject gameObject;
		int subMeshIndex;			// public int subMeshIndex;
		Matrix4x4f transform;
	};

	CUSTOM static internal void InternalCombineIndices(MeshSubsetCombineUtility.SubMeshInstance[] submeshes, [Writable]Mesh combinedMesh)
	{
		InternalMonoSubMeshInstance* instances = Scripting::GetScriptingArrayStart<InternalMonoSubMeshInstance>( submeshes );
		int numSubMeshes = GetScriptingArraySize( submeshes );
		CombineInstances smi;
		smi.resize( numSubMeshes );

		for( int i=0; i!=numSubMeshes; ++i )
		{
			smi[i].mesh				= PPtr<Mesh>(instances[i].meshInstanceID);
			smi[i].vertexOffset		= instances[i].vertexOffset;
			smi[i].subMeshIndex		= instances[i].subMeshIndex;
			smi[i].transform = instances[i].transform;
		}

		Mesh* mesh = combinedMesh;
		CombineMeshIndicesForStaticBatching (smi, *mesh, false, true);
		mesh->SetIsReadable (false);
		mesh->SetKeepIndices (true);
		// Call awake to create the actual VBO; needed since we did SetIsReadable (false)
		mesh->AwakeFromLoad (kDefaultAwakeFromLoad);
	}
END

// When using HDR rendering it can sometime be desirable to switch to LDR rendering during ImageEffect rendering.
CLASS ImageEffectTransformsToLDR : Attribute

END

// Any Image Effect with this attribute will be rendered after opaque geometry but before transparent geometry.
CLASS ImageEffectOpaque : Attribute

END

CSRAW
}