+Unity Runtime codeHEADmaster

1 files changed, 734 insertions, 0 deletions

diff --git a/Runtime/Shaders/Shader.cpp b/Runtime/Shaders/Shader.cpp
new file mode 100644
index 0000000..b33aa00
--- /dev/null
+++ b/Runtime/Shaders/Shader.cpp
@@ -0,0 +1,734 @@
+#include "UnityPrefix.h"
+#include "Shader.h"
+#include "External/shaderlab/Library/intshader.h"
+#include "External/shaderlab/Library/properties.h"
+#include "External/shaderlab/Library/shaderlab.h"
+#include "External/shaderlab/Library/shaderlab.h"
+#include "Material.h"
+#include "ShaderNameRegistry.h"
+#include "Runtime/Utilities/Word.h"
+#include "External/shaderlab/Library/ShaderParser.h"
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/Profiler/ExternalGraphicsProfiler.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/Misc/ResourceManager.h"
+#include "GraphicsCaps.h"
+#include "External/shaderlab/Library/SLParserData.h"
+
+#if UNITY_EDITOR
+#include "External/shaderlab/Library/ShaderWriter.h"
+#endif
+#include "Runtime/Profiler/MemoryProfiler.h"
+
+using std::vector;
+
+// To get a precompiled version of specific platform shader
+// Create this shader in UnityEditor and click on "Open compiled shader"
+//Shader "DefaultShader" 
+//{
+//	SubShader
+//	{
+//		Pass
+//		{
+//		CGPROGRAM
+//
+//			#pragma vertex vert
+//			#pragma fragment frag
+//			float4 vert (float4 pos : POSITION) : SV_POSITION { return mul(UNITY_MATRIX_MVP,pos); }
+//			float4 frag () : COLOR { return float4(1,0,1,1); }
+//		ENDCG
+//		}
+//	} 
+//}
+
+
+
+static const char *gDefaultString =
+"Shader \"Default\" {"
+#if UNITY_XENON
+"SubShader { Pass { Cull Off \n"
+"Program \"vp\" { SubProgram \"xbox360 \" { Keywords { }\n"
+"	Bind \"vertex\" Vertex\n"
+"	Matrix 0 [glstate_matrix_mvp]\n"
+"	\"vs_360\n"
+"	backbbabaaaaaalmaaaaaagmaaaaaaaaaaaaaaceaaaaaaaaaaaaaajaaaaaaaaa\n"
+"	aaaaaaaaaaaaaagiaaaaaabmaaaaaaflpppoadaaaaaaaaabaaaaaabmaaaaaaaa\n"
+"	aaaaaafeaaaaaadaaaacaaaaaaaeaaaaaaaaaaeeaaaaaaaaghgmhdhegbhegffp\n"
+"	gngbhehcgjhifpgnhghaaaklaaadaaadaaaeaaaeaaabaaaaaaaaaaaahghdfpdd\n"
+"	fpdaaadccodacodjdddcdicodaaaklklaaaaaaaaaaaaaagmaaabaaabaaaaaaaa\n"
+"	aaaaaaaaaaaaaaaaaaaaaaabaaaaaaabaaaaaaaaaaaaacjaaaaaaaadbaabbaad\n"
+"	aaaabcaamcaaaaaaaaaaeaaeaaaabcaameaaaaaaaaaaaaadaaaaccaaaaaaaaaa\n"
+"	afpibaaaaaaaagiiaaaaaaaamiapaaaaaabliiaakbabadaamiapaaaaaamgiiaa\n"
+"	klabacaamiapaaaaaalbdejeklababaamiapiadoaagmaadeklabaaaaaaaaaaaa\n"
+"	aaaaaaaaaaaaaaaa\"\n"
+"}}\n"
+"Program \"fp\" { SubProgram \"xbox360 \" { Keywords { }\n"
+"\"ps_360\n"
+"	backbbaaaaaaaakaaaaaaageaaaaaaaaaaaaaaceaaaaaafiaaaaaaiaaaaaaaaa\n"
+"	aaaaaaaaaaaaaadaaaaaaabmaaaaaacdppppadaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+"	aaaaaabmhahdfpddfpdaaadccodacodjdddcdicodaaaklklaaaaaaaaaaaaaaab\n"
+"	aaaaaaaaaaaaaaaaaaaaaabeabpmaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+"	aaaaaaeaaaaaaacebaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab\n"
+"	aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+"	aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadpiaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+"	aaaaaaaabaabmeaaccaaaaaabenmmaaaaaaaaagmmcaaaappaaaaaaaaaaaaaaaa\n"
+"	aaaaaaaa\"\n"
+"}}\n"
+"}}\n"
+#elif UNITY_PS3
+"SubShader { Pass {	Cull Off \n"
+"Program \"vp\" { SubProgram \"ps3 \" { Keywords { }\n"
+"Matrix 256 [glstate_matrix_mvp]\n"
+"Bind \"vertex\" Vertex\n"
+"\"sce_vp_rsx // 4 instructions using 1 registers\n"
+"[Configuration]\n"
+"8\n"
+"0000000400010100\n"
+"[Microcode]\n"
+"64\n"
+"401f9c6c01d0300d8106c0c360403f80401f9c6c01d0200d8106c0c360405f80\n"
+"401f9c6c01d0100d8106c0c360409f80401f9c6c01d0000d8106c0c360411f81\n"
+"\"\n"
+"}}\n"
+"Program \"fp\" { SubProgram \"ps3 \" { Keywords { }\n"
+"\"sce_fp_rsx // 2 instructions using 2 registers\n"
+"[Configuration]\n"
+"24\n"
+"ffffffff000000200000ffff000000000000840002000000\n"
+"[Microcode]\n"
+"32\n"
+"1e81014008021c9cc8000001c800000100003f80000000000000000000000000\n"
+"\"\n"
+"}}\n"
+"}}\n"
+
+#else
+
+#if GFX_SUPPORTS_D3D11
+"SubShader { Pass {\n"
+"Program \"vp\" {\n"
+"SubProgram \"d3d11 \" { Bind \"vertex\" Vertex ConstBuffer \"UnityPerDraw\" 336 Matrix 0 [glstate_matrix_mvp] 4 BindCB \"UnityPerDraw\" 0\n"
+"\"vs_dx11\n"
+"eefiecedijhpljdppnfhjnjaadaickkmhicpkjbcabaaaaaaheabaaaaadaaaaaa\n"
+"cmaaaaaagaaaaaaajeaaaaaaejfdeheocmaaaaaaabaaaaaaaiaaaaaacaaaaaaa\n"
+"aaaaaaaaaaaaaaaaadaaaaaaaaaaaaaaapapaaaafaepfdejfeejepeoaaklklkl\n"
+"epfdeheocmaaaaaaabaaaaaaaiaaaaaacaaaaaaaaaaaaaaaabaaaaaaadaaaaaa\n"
+"aaaaaaaaapaaaaaafdfgfpfaepfdejfeejepeoaafdeieefcniaaaaaaeaaaabaa\n"
+"dgaaaaaafjaaaaaeegiocaaaaaaaaaaaaeaaaaaafpaaaaadpcbabaaaaaaaaaaa\n"
+"ghaaaaaepccabaaaaaaaaaaaabaaaaaagiaaaaacabaaaaaadiaaaaaipcaabaaa\n"
+"aaaaaaaafgbfbaaaaaaaaaaaegiocaaaaaaaaaaaabaaaaaadcaaaaakpcaabaaa\n"
+"aaaaaaaaegiocaaaaaaaaaaaaaaaaaaaagbabaaaaaaaaaaaegaobaaaaaaaaaaa\n"
+"dcaaaaakpcaabaaaaaaaaaaaegiocaaaaaaaaaaaacaaaaaakgbkbaaaaaaaaaaa\n"
+"egaobaaaaaaaaaaadcaaaaakpccabaaaaaaaaaaaegiocaaaaaaaaaaaadaaaaaa\n"
+"pgbpbaaaaaaaaaaaegaobaaaaaaaaaaadoaaaaab\"\n"
+"}\n"
+"SubProgram \"d3d11_9x \" {\n"
+"Bind \"vertex\" Vertex\n"
+"ConstBuffer \"UnityPerDraw\" 336 \n"
+"Matrix 0 [glstate_matrix_mvp] 4\n"
+"BindCB \"UnityPerDraw\" 0\n"
+"\"vs_4_0_level_9_1\n"
+"eefieceddggiiplcpkoeljnckhkjahapknjdfpkhabaaaaaadeacaaaaaeaaaaaa\n"
+"daaaaaaaomaaaaaammabaaaaaaacaaaaebgpgodjleaaaaaaleaaaaaaaaacpopp\n"
+"iaaaaaaadeaaaaaaabaaceaaaaaadaaaaaaadaaaaaaaceaaabaadaaaaaaaaaaa\n"
+"aeaaabaaaaaaaaaaaaaaaaaaaaacpoppbpaaaaacafaaaaiaaaaaapjaafaaaaad\n"
+"aaaaapiaaaaaffjaacaaoekaaeaaaaaeaaaaapiaabaaoekaaaaaaajaaaaaoeia\n"
+"aeaaaaaeaaaaapiaadaaoekaaaaakkjaaaaaoeiaaeaaaaaeaaaaapiaaeaaoeka\n"
+"aaaappjaaaaaoeiaaeaaaaaeaaaaadmaaaaappiaaaaaoekaaaaaoeiaabaaaaac\n"
+"aaaaammaaaaaoeiappppaaaafdeieefcniaaaaaaeaaaabaadgaaaaaafjaaaaae\n"
+"egiocaaaaaaaaaaaaeaaaaaafpaaaaadpcbabaaaaaaaaaaaghaaaaaepccabaaa\n"
+"aaaaaaaaabaaaaaagiaaaaacabaaaaaadiaaaaaipcaabaaaaaaaaaaafgbfbaaa\n"
+"aaaaaaaaegiocaaaaaaaaaaaabaaaaaadcaaaaakpcaabaaaaaaaaaaaegiocaaa\n"
+"aaaaaaaaaaaaaaaaagbabaaaaaaaaaaaegaobaaaaaaaaaaadcaaaaakpcaabaaa\n"
+"aaaaaaaaegiocaaaaaaaaaaaacaaaaaakgbkbaaaaaaaaaaaegaobaaaaaaaaaaa\n"
+"dcaaaaakpccabaaaaaaaaaaaegiocaaaaaaaaaaaadaaaaaapgbpbaaaaaaaaaaa\n"
+"egaobaaaaaaaaaaadoaaaaabejfdeheocmaaaaaaabaaaaaaaiaaaaaacaaaaaaa\n"
+"aaaaaaaaaaaaaaaaadaaaaaaaaaaaaaaapapaaaafaepfdejfeejepeoaaklklkl\n"
+"epfdeheocmaaaaaaabaaaaaaaiaaaaaacaaaaaaaaaaaaaaaabaaaaaaadaaaaaa\n"
+"aaaaaaaaapaaaaaafdfgfpfaepfdejfeejepeoaa\"\n"
+"}\n"
+"}\n"
+"Program \"fp\" {\n"
+"SubProgram \"d3d11 \" {\n"
+"\"ps_dx11\n"
+"eefiecedlfbokalingbkfpbcgbelaibibjjpegjnabaaaaaalaaaaaaaadaaaaaa\n"
+"cmaaaaaadmaaaaaahaaaaaaaejfdeheoaiaaaaaaaaaaaaaaaiaaaaaaepfdeheo\n"
+"cmaaaaaaabaaaaaaaiaaaaaacaaaaaaaaaaaaaaaaaaaaaaaadaaaaaaaaaaaaaa\n"
+"apaaaaaafdfgfpfegbhcghgfheaaklklfdeieefcdiaaaaaaeaaaaaaaaoaaaaaa\n"
+"gfaaaaadpccabaaaaaaaaaaadgaaaaaipccabaaaaaaaaaaaaceaaaaaaaaaiadp\n"
+"aaaaaaaaaaaaiadpaaaaiadpdoaaaaab\"\n"
+"}\n"
+"SubProgram \"d3d11_9x \" {\n"
+"\"ps_4_0_level_9_1\n"
+"eefiecednclpehpkkhodapchnemhifoohfkahfmoabaaaaaaamabaaaaaeaaaaaa\n"
+"daaaaaaaiiaaaaaamiaaaaaaniaaaaaaebgpgodjfaaaaaaafaaaaaaaaaacpppp\n"
+"cmaaaaaaceaaaaaaaaaaceaaaaaaceaaaaaaceaaaaaaceaaaaaaceaaaaacpppp\n"
+"fbaaaaafaaaaapkaaaaaiadpaaaaaaaaaaaaiadpaaaaiadpabaaaaacaaaiapia\n"
+"aaaaoekappppaaaafdeieefcdiaaaaaaeaaaaaaaaoaaaaaagfaaaaadpccabaaa\n"
+"aaaaaaaadgaaaaaipccabaaaaaaaaaaaaceaaaaaaaaaiadpaaaaaaaaaaaaiadp\n"
+"aaaaiadpdoaaaaabejfdeheoaiaaaaaaaaaaaaaaaiaaaaaaepfdeheocmaaaaaa\n"
+"abaaaaaaaiaaaaaacaaaaaaaaaaaaaaaaaaaaaaaadaaaaaaaaaaaaaaapaaaaaa\n"
+"fdfgfpfegbhcghgfheaaklkl\"\n"
+"}\n"
+"}\n"
+"}}"
+#endif
+
+"	SubShader { Tags { \"ForceSupported\" = \"True\" } Pass{ Cull Off SetTexture[_Dummy] { constantColor (1,0,1,1) combine constant }}}	 \n"
+#endif
+"}";
+
+int*							gShaderLabContainer = NULL;
+
+static ShaderLab::IntShader*	gDefaultShaderLabShader = NULL;
+static Shader*					gDefaultShader = NULL;
+static Shader*					s_ClearShader = NULL;
+static void MakeDefaultShaderLabShader ();
+
+Shader::Shader(MemLabelId label, ObjectCreationMode mode)
+: Super(label, mode)
+, m_ShaderIsBaked(false)
+{
+	MakeDefaultShaderLabShader ();
+	m_Shader = gDefaultShaderLabShader;
+	m_ShadowCasterPass = NULL;
+	m_ShadowCollectorPass = NULL;
+	m_NeedsParsing = false;
+
+	#if UNITY_EDITOR
+	m_ParsedForm = NULL;
+	#endif
+
+	if (mode != kCreateObjectFromNonMainThread)
+		PostLoad ();
+}
+
+Shader *Shader::GetDefault ()
+{
+	if (!gDefaultShader) {
+		SET_ALLOC_OWNER(gShaderLabContainer);
+		gDefaultShader = NEW_OBJECT(Shader);
+		gDefaultShader->Reset();
+		#if !UNITY_RELEASE
+		// in Shader's AwakeFromLoad it will try to parse script and call PostLoad
+		// we basically doing the same, but we assign default shader directly (w/o script)
+		gDefaultShader->HackSetAwakeWasCalled();
+		#endif
+
+		gDefaultShader->m_Shader = gDefaultShaderLabShader;
+		gDefaultShader->PostLoad();
+		gDefaultShader->SetHideFlags (kHideAndDontSave);
+	}
+	return gDefaultShader;
+}
+
+Shader* Shader::GetScreenClearShader ()
+{
+	Assert (s_ClearShader);
+	return s_ClearShader;
+}
+
+
+void Shader::LoadDefaultShaders ()
+{
+	GetDefault ();
+
+	#if GFX_SUPPORTS_D3D11 || GFX_SUPPORTS_XENON
+	if (IsGfxDevice())
+	{
+		Assert (!s_ClearShader);
+		s_ClearShader = GetBuiltinResource<Shader> ("Internal-Clear.shader");
+	}
+	#endif
+}
+
+
+Shader::~Shader ()
+{
+	if (m_Shader != gDefaultShaderLabShader)
+		UNITY_DELETE(m_Shader, kMemShader);
+
+	if (this == gDefaultShader)
+		gDefaultShader = NULL;
+	
+	#if UNITY_EDITOR
+	UNITY_DELETE( m_ParsedForm, kMemShader);
+	#endif
+}
+
+bool Shader::MainThreadCleanup ()
+{
+	if (m_Shader != gDefaultShaderLabShader)
+	{
+		m_Shader->MainThreadCleanup ();
+	}
+	
+	return true;
+}
+
+ShaderLab::PropertySheet *Shader::MakeProperties () const
+{
+	return m_Shader->MakeProperties ();
+}
+
+#if UNITY_EDITOR
+
+UInt32 Shader::CalculateUsedVertexComponents (bool lightmapped)
+{
+	if (m_Shader == NULL)
+		return 0;
+
+	UInt32 mask = 0;
+
+	const ShaderLab::IntShader::SubShaders& subshaders = m_Shader->GetSubShaders();
+	for (int i=0;i<subshaders.size();i++)
+	{
+		int npasses = subshaders[i]->GetTotalPassCount();
+		for (int p = 0; p < npasses; ++p)
+		{
+			mask |= subshaders[i]->GetPass(p)->CalculateUsedVertexComponents(lightmapped);
+		}
+	}
+
+	return mask;
+}
+
+int Shader::GetPropertyCount () const
+{
+	if (!m_ParsedForm)
+		return 0;
+	return m_ParsedForm->m_PropInfo.GetPropertyCount();
+}
+
+const ShaderLab::ParserProperty* Shader::GetPropertyInfo (int propertyNo) const
+{
+	if (!m_ParsedForm)
+		return NULL;
+	return m_ParsedForm->m_PropInfo.GetPropertyInfo (propertyNo);
+}
+
+bool Shader::HasClip() const
+{
+	return m_ParsedForm ? m_ParsedForm->HasClip() : false;
+}
+
+char const* Shader::GetCustomEditorName() const
+{
+	if (!m_Shader)
+			return NULL;
+	return m_Shader->GetCustomEditor ().c_str ();
+}
+
+#endif
+
+PROFILER_INFORMATION(gSetPassProfile, "Shader.SetPass", kProfilerRender);
+
+const ChannelAssigns* Shader::SetPass( int subshaderIndex, int passNo, UInt32 stateKey, const ShaderLab::PropertySheet* props )
+{
+	PROFILER_AUTO(gSetPassProfile, this)
+	return m_Shader->GetSubShader(subshaderIndex).SetPass (passNo, stateKey, props);
+}
+
+bool Shader::CanPassBeRecorded(int subshaderIndex, int passNo) const
+{
+	const ShaderLab::Pass* pass = m_Shader->GetSubShader(subshaderIndex).GetPass(passNo);
+	return pass->CanPassBeRecorded();
+}
+
+ShaderLab::Pass* Shader::GetShadowCasterPassToUse(int subshaderIndex)
+{
+	ShaderLab::SubShader& subShader = m_Shader->GetSubShader(subshaderIndex);
+	if (!subShader.ShadowCasterPassEnabled())
+		return NULL;
+	int ssPass = subShader.GetShadowCasterPassIndex();
+	if (ssPass >= 0)
+		return subShader.GetPass(ssPass);
+	return m_ShadowCasterPass;
+}
+
+ShaderLab::Pass* Shader::GetShadowCollectorPassToUse(int subshaderIndex)
+{
+	ShaderLab::SubShader& subShader = m_Shader->GetSubShader(subshaderIndex);
+	int ssPass = subShader.GetShadowCollectorPassIndex();
+	if (ssPass >= 0)
+		return subShader.GetPass(ssPass);
+	return m_ShadowCollectorPass;
+}
+
+
+int Shader::GetActiveSubShaderIndex () const
+{
+	return GetShaderLabShader()->GetActiveSubShaderIndex();
+}
+
+bool Shader::SetScript (const TextAsset::ScriptString& script)
+{
+	Super::SetScriptDontDirty (script);
+
+	m_ShadowCasterPass = NULL;
+	m_ShadowCollectorPass = NULL;
+
+	ParseAndPostLoad( script.c_str(), script.size() );
+
+	return m_Shader != gDefaultShaderLabShader;
+}
+
+
+namespace ShaderLab {
+extern const char* kPassLightModeTypeNames[kShaderPassTypeCount];
+}
+
+
+static ShaderLab::Pass* FindLightModePass( ShaderLab::IntShader* shader, ShaderPassType type )
+{
+	using ShaderLab::TagMap;
+	typedef ShaderLab::IntShader::SubShaders SubShaders;
+
+	static const int lightModeTagID = ShaderLab::GetShaderTagID("LIGHTMODE");
+
+	const SubShaders& subshaders = shader->GetSubShaders();
+	for( SubShaders::const_iterator it = subshaders.begin(); it != subshaders.end(); ++it )
+	{
+		ShaderLab::SubShader& ss = **it;
+		for( int i = 0; i < ss.GetValidPassCount (); ++i )
+		{
+			const TagMap& tags = ss.GetPass(i)->GetTags();
+			TagMap::const_iterator found = tags.find (lightModeTagID);
+			if( found != tags.end() && (StrICmp( ShaderLab::GetShaderTagName(found->second), ShaderLab::kPassLightModeTypeNames[type] ) == 0 ) )
+			{
+				return ss.GetPass(i);
+			}
+		}
+	}
+
+	return NULL;
+}
+
+void Shader::PostLoad ()
+{
+	m_Shader->PostLoad();
+
+	// Find out shadow caster/collector passes
+	Assert (m_ShadowCasterPass == NULL && m_ShadowCollectorPass == NULL);
+	m_ShadowCasterPass = FindLightModePass( m_Shader, kPassShadowCaster );
+	m_ShadowCollectorPass = FindLightModePass( m_Shader, kPassShadowCollector );
+}
+
+void Shader::AddMaterialUser( ListNode<Unity::Material>& node )
+{
+	m_Users.push_back( node );
+}
+
+PROFILER_INFORMATION(gShaderParseProfile, "Shader.Parse", kProfilerRender);
+
+void Shader::Parse (const char *str, size_t strLength)
+{
+	PROFILER_AUTO(gShaderParseProfile, this);
+	SET_ALLOC_OWNER(this);
+
+	m_NeedsParsing = false;
+	if( m_Shader != gDefaultShaderLabShader )
+		UNITY_DELETE(m_Shader, kMemShader);
+
+	#if UNITY_EDITOR
+	UNITY_DELETE( m_ParsedForm, kMemShader);
+	m_ParsedForm = NULL;
+	ShaderErrors& errors = m_Errors;
+	#else
+	ShaderErrors errors;
+	#endif
+
+	ShaderLab::ParserShader* parsedForm = NULL;
+	m_Shader = ParseShader (str, strLength, m_Dependencies, m_ShaderIsBaked, &parsedForm, errors, GetGfxDevice().GetRenderer());
+	// In editor, keep the parsed form so we can serialize shaders out specific for a platform. In players, delete parsed form now.
+	#if UNITY_EDITOR
+	m_ParsedForm = parsedForm;
+	#else
+	UNITY_DELETE( parsedForm, kMemShader);
+	#endif
+
+
+	m_ShadowCasterPass = NULL;
+	m_ShadowCollectorPass = NULL;
+	m_ShaderName = g_LastParsedShaderName;
+
+	// For no-fixed function hardware and shaders that ended up having only shadow related passes
+	// (like VertexLit), insert the pass from default shader. Otherwise the shader is supported, but
+	// has no passes suitable for any rendering path, hence all objects with it are not rendered at all.
+	if (!gGraphicsCaps.hasFixedFunction && m_Shader && gDefaultShaderLabShader)
+	{
+		ShaderLab::SubShader& ss = m_Shader->GetActiveSubShader();
+		if (ss.GetHasOnlyShadowPasses()) {
+			printf_console("Unsupported: %s\n", m_ShaderName.c_str());
+			ss.InsertDefaultPass (gDefaultShaderLabShader->GetActiveSubShader().GetPass(0));
+		}
+	}
+
+	if( !m_Shader )
+	{
+		printf_console("Unsupported: %s\n", m_ShaderName.c_str());
+		m_Shader = gDefaultShaderLabShader;
+		return;
+	}
+
+	if (m_Shader->HasNoSubShaders())
+	{
+		char buf[256];
+		snprintf(buf, 255, "No valid subshaders in '%s'.shader", GetScriptClassName().c_str());
+		ErrorStringObject (buf, this);
+		UNITY_DELETE(m_Shader, kMemShader);
+		m_Shader = gDefaultShaderLabShader;
+	}
+}
+
+
+void Shader::AwakeFromLoad (AwakeFromLoadMode awakeMode)
+{
+	SET_ALLOC_OWNER(this);
+	Super::AwakeFromLoad (awakeMode);
+	const ScriptString& s = GetScript();
+	ParseAndPostLoad( s.c_str(), s.size() );
+}
+
+void Shader::AwakeFromLoadThreaded ()
+{
+	Super::AwakeFromLoadThreaded ();
+
+	// In some cases a shader is constructed (on the loading thread, has shader pointing
+	// to the default one, and m_NeedsParsing flag set to false). Later on
+	// actual shader is being loaded, but no one resets the m_NeedsParsing flag.
+	// This seems to happen only in a very rare combination of shaders loaded via fallbacks
+	// combined with shaders being referenced from scripts only; and even then it
+	// highly depends on the order the shaders end up being loaded. Couldn't
+	// make an automated repro case.
+	if (m_Shader == gDefaultShaderLabShader)
+	{
+		m_Shader = NULL;
+		m_ShadowCasterPass = NULL;
+		m_ShadowCollectorPass = NULL;
+		m_NeedsParsing = true;
+	}
+}
+
+template<class TransferFunc>
+void Shader::Transfer (TransferFunc& transfer)
+{
+	#if UNITY_EDITOR
+	if (transfer.IsBuildingTargetPlatform(kBuildAnyPlayerData))
+	{
+		UnityStr newSource = ProduceTargetSpecificShader (m_Script, m_ParsedForm, transfer.GetBuildingTarget());
+
+		Super::Super::Transfer (transfer);
+		transfer.Transfer (newSource, "m_Script", kHideInEditorMask);
+		transfer.Transfer (m_PathName, "m_PathName", kHideInEditorMask);
+	}
+	else
+		Super::Transfer (transfer);
+	#else
+	Super::Transfer (transfer);
+	#endif
+
+	transfer.Transfer (m_Dependencies, "m_Dependencies");
+
+	// Shaders in player data files and asset bundles should get "shader is baked" flag,
+	// so they get their dependencies directly instead of through script mapper.
+	// Need to set this flag to true when building the data files, but properly
+	// reset it back afterwards.
+	if (transfer.IsWritingGameReleaseData())
+	{
+		bool shaderIsBaked = true;
+		transfer.Transfer (shaderIsBaked, "m_ShaderIsBaked");
+	}
+	else
+	{
+		transfer.Transfer (m_ShaderIsBaked, "m_ShaderIsBaked");
+	}
+
+	transfer.Align();
+
+	#if UNITY_EDITOR
+	if (!transfer.IsSerializingForGameRelease() && !transfer.IsRemapPPtrTransfer ())
+	{
+		transfer.Transfer (m_Errors.GetErrors(), "errors");
+		transfer.Transfer (m_DefaultTextures, "m_DefaultTextures", kHideInEditorMask);
+	}
+	#endif
+
+}
+
+char const* Shader::GetName () const {
+	// shader name is the name of the shader, not the filename
+	return GetScriptClassName().c_str();
+}
+
+
+bool Shader::IsSupported () const
+{
+	return m_Shader != gDefaultShaderLabShader;
+}
+
+int Shader::GetSubShaderWithTagValue (int tagNameID, int tagValueID) const
+{
+	using ShaderLab::TagMap;
+	typedef ShaderLab::IntShader::SubShaders SubShaders;
+
+	const SubShaders& ss = m_Shader->GetSubShaders();
+	int idx = 0;
+	for( SubShaders::const_iterator i = ss.begin(); i != ss.end(); ++i )
+	{
+		const TagMap& tags = (**i).GetTags();
+		TagMap::const_iterator j = tags.find(tagNameID);
+		if (j != tags.end () && j->second == tagValueID)
+			return idx;
+		idx++;
+	}
+	return -1;
+}
+
+bool Shader::IsDependentOn (PPtr<Shader> shader) const
+{
+	for (int i = 0; i < m_Dependencies.size (); ++i)
+		if (m_Dependencies[i] == shader ||
+			m_Dependencies[i]->IsDependentOn (shader))
+			return true;
+
+	return false;
+}
+
+Shader* Shader::GetDependency (const std::string& name)
+{
+	if (!m_Shader)
+		return NULL;
+	const std::string* dependencyName = m_Shader->GetDependency (name);
+	if (!dependencyName || dependencyName->empty())
+		return NULL;
+	Shader* res = FindShaderLabShader (*dependencyName, m_Dependencies, m_ShaderIsBaked);
+	return res;
+}
+
+
+void Shader::UnloadDefaultShaderLabShader()
+{
+	UNITY_DELETE(gDefaultShaderLabShader, kMemShader);
+	gDefaultShaderLabShader = NULL;
+	if (gDefaultShader)
+		gDefaultShader->m_Shader = NULL;
+}
+
+void Shader::LoadDefaultShaderLabShader()
+{
+	ShaderLab::ParserShader* parsedForm = NULL;
+	ShaderErrors errors;
+	ShaderPtrVector dependencies;
+	gDefaultShaderLabShader = ParseShader (gDefaultString, strlen(gDefaultString), dependencies, false, &parsedForm, errors, GetGfxDevice().GetRenderer());
+	if (errors.HasErrorsOrWarnings()) {
+		ErrorString ("Default Shader has errors! Something is wrong.");
+	}
+	UNITY_DELETE(parsedForm, kMemShader);
+
+	if (gDefaultShader)
+	{
+		gDefaultShader->m_Shader = gDefaultShaderLabShader;
+		gDefaultShader->PostLoad();
+	}
+}
+
+static void MakeDefaultShaderLabShader ()
+{
+	if (gDefaultShaderLabShader)
+		return;
+	gShaderLabContainer = UNITY_NEW_AS_ROOT(int, kMemShader, "ShaderLab", "");
+	SET_ALLOC_OWNER(gShaderLabContainer);
+	ShaderLab::InitShaderLab ();
+
+	Shader::LoadDefaultShaderLabShader();
+}
+
+void CleanupShaders ()
+{
+	Shader::UnloadDefaultShaderLabShader();
+	ShaderLab::CleanupShaderLab();
+	// still some allocations left in shaderlab, so we don't want to delete this one before someone has cleaned up shaderlab
+//	UNITY_DELETE(gShaderLabContainer, kMemShader);
+}
+
+void Shader::DeleteAllShaders( std::vector<SInt32>& outShaderObjects )
+{
+	outShaderObjects.clear();
+	Object::FindAllDerivedObjects (ClassID (Shader), &outShaderObjects);
+	for (std::vector<SInt32>::iterator i = outShaderObjects.begin(); i != outShaderObjects.end(); i++)
+	{
+		Shader *s = PPtr<Shader> (*i);
+		for (MaterialList::iterator sit = s->m_Users.begin(); sit != s->m_Users.end(); ++sit)
+		{
+			(*sit)->InvalidateDisplayLists();
+		}
+		if (s->m_Shader != gDefaultShaderLabShader)
+		{
+			UNITY_DELETE(s->m_Shader, kMemShader);
+			s->m_Shader = NULL;
+			s->m_ShadowCasterPass = NULL;
+			s->m_ShadowCollectorPass = NULL;
+			s->m_NeedsParsing = true;
+		}
+	}
+}
+
+void Shader::RecreateAllShaders( const std::vector<SInt32>& shaderObjects )
+{
+	for( std::vector<SInt32>::const_iterator i = shaderObjects.begin(); i != shaderObjects.end(); ++i )
+	{
+		Shader *s = PPtr<Shader> (*i);
+		if( s != gDefaultShader )
+		{
+			const ScriptString& script = s->GetScript();
+			s->ParseAndPostLoad( script.c_str(), script.size() );
+		}
+	}
+}
+
+
+void Shader::ReloadAllShaders()
+{
+	std::vector<SInt32> derivedObjects;
+	DeleteAllShaders( derivedObjects );
+	RecreateAllShaders( derivedObjects );
+}
+
+void Shader::SetGLobalMaximumShaderLOD( int lod )
+{
+	if( ShaderLab::g_GlobalMaximumShaderLOD == lod )
+		return;
+	ShaderLab::g_GlobalMaximumShaderLOD = lod;
+
+	// notify all shaders of global LOD change
+	std::vector<SInt32> shaders;
+	Object::FindAllDerivedObjects (ClassID (Shader), &shaders);
+	for (std::vector<SInt32>::iterator i = shaders.begin(); i != shaders.end(); ++i)
+	{
+		Shader* s = PPtr<Shader> (*i);
+		s->m_Shader->PostLoad();
+	}
+}
+
+int Shader::GetGlobalMaximumShaderLOD()
+{
+	return ShaderLab::g_GlobalMaximumShaderLOD;
+}
+
+void Shader::SetMaximumShaderLOD( int lod )
+{
+	if(GetMaximumShaderLOD() == lod)
+		return;
+
+	GetShaderLabShader()->SetMaximumShaderLOD(lod);
+}
+
+int Shader::GetMaximumShaderLOD( ) const
+{
+	return GetShaderLabShader()->GetMaximumShaderLOD();
+}
+
+
+IMPLEMENT_CLASS (Shader)
+IMPLEMENT_OBJECT_SERIALIZE (Shader)