private void ComputeSliceAndMask(ShaderKeyword keyword, out uint slice, out uint mask) { int index = keyword.GetKeywordIndex(); slice = (uint)(index / k_SizeInBits); mask = (uint)(1 << (index % k_SizeInBits)); }
static public int constructor(IntPtr l) { try { #if DEBUG var method = System.Reflection.MethodBase.GetCurrentMethod(); string methodName = GetMethodName(method); #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.BeginSample(methodName); #else Profiler.BeginSample(methodName); #endif #endif UnityEngine.Rendering.ShaderKeyword o; System.String a1; checkType(l, 2, out a1); o = new UnityEngine.Rendering.ShaderKeyword(a1); pushValue(l, true); pushValue(l, o); return(2); } catch (Exception e) { return(error(l, e)); } #if DEBUG finally { #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.EndSample(); #else Profiler.EndSample(); #endif } #endif }
static public int GetName(IntPtr l) { try { #if DEBUG var method = System.Reflection.MethodBase.GetCurrentMethod(); string methodName = GetMethodName(method); #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.BeginSample(methodName); #else Profiler.BeginSample(methodName); #endif #endif UnityEngine.Rendering.ShaderKeyword self = (UnityEngine.Rendering.ShaderKeyword)checkSelf(l); var ret = self.GetName(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } #if DEBUG finally { #if UNITY_5_5_OR_NEWER UnityEngine.Profiling.Profiler.EndSample(); #else Profiler.EndSample(); #endif } #endif }
public static ShaderKeywordType GetGlobalKeywordType(ShaderKeyword index) { if (index.IsValid()) { return(GetGlobalShaderKeywordType(index.m_Index)); } return(ShaderKeywordType.UserDefined); }
public void Disable(ShaderKeyword keyword) { if (keyword.m_IsLocal || !keyword.IsValid()) { DisableKeywordName(this, keyword.m_Name); } else { DisableGlobalKeyword(this, keyword.m_Index); } }
public void Enable(ShaderKeyword keyword) { CheckKeywordCompatible(keyword); if (keyword.m_IsLocal || !keyword.IsValid()) { EnableKeywordName(this, keyword.m_Name); } else { EnableGlobalKeyword(this, keyword.m_Index); } }
static public int GetKeywordName(IntPtr l) { try { UnityEngine.Rendering.ShaderKeyword self = (UnityEngine.Rendering.ShaderKeyword)checkSelf(l); var ret = self.GetKeywordName(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
private void CheckKeywordCompatible(ShaderKeyword keyword) { if (keyword.m_IsLocal) { if (m_Shader != IntPtr.Zero) { Assert.IsTrue(!keyword.m_IsCompute, "Trying to use a keyword that comes from a different shader."); } else { Assert.IsTrue(keyword.m_IsCompute, "Trying to use a keyword that comes from a different shader."); } } }
static public int constructor(IntPtr l) { try { UnityEngine.Rendering.ShaderKeyword o; System.String a1; checkType(l, 2, out a1); o = new UnityEngine.Rendering.ShaderKeyword(a1); pushValue(l, true); pushValue(l, o); return(2); } catch (Exception e) { return(error(l, e)); } }
public void Disable(ShaderKeyword keyword) { if (!keyword.IsValid()) { return; } uint slice, mask; ComputeSliceAndMask(keyword, out slice, out mask); fixed(uint *bits = m_Bits) { bits[slice] &= ~mask; } }
public bool IsEnabled(ShaderKeyword keyword) { if (!keyword.IsValid()) { return(false); } uint slice, mask; ComputeSliceAndMask(keyword, out slice, out mask); fixed(uint *bits = m_Bits) { return((bits[slice] & mask) != 0); } }
public ShaderKeyword[] GetShaderKeywords() { ShaderKeyword[] shaderKeywords = new ShaderKeyword[ShaderKeyword.k_MaxShaderKeywords]; int keywordCount = 0; for (int keywordIndex = 0; keywordIndex < ShaderKeyword.k_MaxShaderKeywords; ++keywordIndex) { ShaderKeyword keyword = new ShaderKeyword(keywordIndex); if (IsEnabled(keyword)) { shaderKeywords[keywordCount] = keyword; ++keywordCount; } } Array.Resize <ShaderKeyword>(ref shaderKeywords, keywordCount); return(shaderKeywords); }
public static ShaderKeywordType GetKeywordType(ComputeShader shader, ShaderKeyword index) { return(ShaderKeyword.GetComputeShaderKeywordType(shader, index)); }
public ShaderKeyword(string keywordName) { this.m_KeywordIndex = ShaderKeyword.GetGlobalKeywordIndex(keywordName); }
public LitShaderPreprocessor() { m_ForceForwardEmissive = new UnityEngine.Rendering.ShaderKeyword("_FORCE_FORWARD_EMISSIVE"); }
public static void SetShaderKeywordIndex(UnityEngine.Rendering.ShaderKeyword shaderKeyword, int keywordIndex) { KEYWORD_INDEX_FIELDINFO.SetValue(shaderKeyword, keywordIndex); }
[FreeFunction("ShaderScripting::GetKeywordName")] extern public static string GetKeywordName(Shader shader, ShaderKeyword index);
public static string GetGlobalKeywordName(ShaderKeyword index) { return(index.m_Name); }
internal static ShaderKeywordType GetComputeShaderKeywordType(ComputeShader shader, ShaderKeyword index) { return(ShaderKeyword.GetComputeShaderKeywordType_Injected(shader, ref index)); }
public bool IsEnabled(ShaderKeyword keyword) { CheckKeywordCompatible(keyword); return(IsKeywordNameEnabled(this, keyword.m_Name)); }
public static bool IsKeywordLocal(ShaderKeyword keyword) { return(keyword.m_IsLocal); }
[FreeFunction("ShaderScripting::GetKeywordType")] extern public static ShaderKeywordType GetKeywordType(Shader shader, ShaderKeyword index);
public static string GetKeywordName(ComputeShader shader, ShaderKeyword index) { return(ShaderKeyword.GetComputeShaderKeywordName(shader, index)); }
public ShaderKeyword(Shader shader, string keywordName) { this.m_KeywordIndex = ShaderKeyword.GetKeywordIndex(shader, keywordName); }
public static int GetShaderKeywordIndex(UnityEngine.Rendering.ShaderKeyword shaderKeyword) { return((int)KEYWORD_INDEX_FIELDINFO.GetValue(shaderKeyword)); }
[FreeFunction("ShaderScripting::IsKeywordLocal")] extern public static bool IsKeywordLocal(ShaderKeyword index);
public static ShaderKeywordType GetKeywordType(ComputeShader shader, ShaderKeyword index) { return(ShaderKeywordType.UserDefined); }
bool LitShaderStripper(HDRenderPipelineAsset hdrpAsset, Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData) { if (CommonShaderStripper(hdrpAsset, shader, snippet, inputData)) { return(true); } bool isGBufferPass = snippet.passName == "GBuffer"; //bool isForwardPass = snippet.passName == "Forward"; bool isDepthOnlyPass = snippet.passName == "DepthOnly"; bool isTransparentForwardPass = snippet.passName == "TransparentDepthPostpass" || snippet.passName == "TransparentBackface" || snippet.passName == "TransparentDepthPrepass"; // When using forward only, we never need GBuffer pass (only Forward) if (hdrpAsset.renderPipelineSettings.supportOnlyForward && isGBufferPass) { return(true); } if (inputData.shaderKeywordSet.IsEnabled(m_Transparent)) { // If transparent, we never need GBuffer pass. if (isGBufferPass) { return(true); } } else // Opaque { // If opaque, we never need transparent specific passes (even in forward only mode) if (isTransparentForwardPass) { return(true); } // When we are in deferred (i.e !hdrpAsset.renderPipelineSettings.supportOnlyForward), we only support tile lighting if (!hdrpAsset.renderPipelineSettings.supportOnlyForward && inputData.shaderKeywordSet.IsEnabled(m_ClusterLighting)) { return(true); } if (isDepthOnlyPass) { // When we are full forward, we don't have depth prepass without writeNormalBuffer if (hdrpAsset.renderPipelineSettings.supportOnlyForward && !inputData.shaderKeywordSet.IsEnabled(m_WriteNormalBuffer)) { return(true); } } // TODO: add an option to say we are using only the deferred shader variant (for Lit) //if (0) { // If opaque and not forward only, then we only need the forward debug pass. //if (isForwardPass && !inputData.shaderKeywordSet.IsEnabled(m_DebugDisplay)) // return true; } } //forest-begin: G-Buffer motion vectors if (inputData.shaderCompilerPlatform != ShaderCompilerPlatform.PS4 && inputData.shaderCompilerPlatform != ShaderCompilerPlatform.XboxOneD3D11 && inputData.shaderCompilerPlatform != ShaderCompilerPlatform.XboxOneD3D12) { if (shader.name == "HDRenderPipeline/Lit" || shader.name == "HDRenderPipeline/LitTessellation") { var gBufferMotionVectors = new UnityEngine.Rendering.ShaderKeyword("GBUFFER_MOTION_VECTORS"); var isGBufferMotionVectors = inputData.shaderKeywordSet.IsEnabled(gBufferMotionVectors); if (hdrpAsset.GetFrameSettings().enableGBufferMotionVectors) { if (isGBufferPass && !isGBufferMotionVectors) { return(true); } } else { if (isGBufferMotionVectors) { return(true); } } } } //forest-end: // TODO: Tests for later // We need to find a way to strip useless shader features for passes/shader stages that don't need them (example, vertex shaders won't ever need SSS Feature flag) // This causes several problems: // - Runtime code that "finds" shader variants based on feature flags might not find them anymore... thus fall backing to the "let's give a score to variant" code path that may find the wrong variant. // - Another issue is that if a feature is declared without a "_" fall-back, if we strip the other variants, none may be left to use! This needs to be changed on our side. //if (snippet.shaderType == ShaderType.Vertex && inputData.shaderKeywordSet.IsEnabled(m_FeatureSSS)) // return true; return(false); }
public static string GetKeywordName(ComputeShader shader, ShaderKeyword index) { return(index.m_Name); }
internal static string GetComputeShaderKeywordName(ComputeShader shader, ShaderKeyword index) { return(ShaderKeyword.GetComputeShaderKeywordName_Injected(shader, ref index)); }