public ModelMaterial(byte[] inData) { using (MemoryStream ms = new MemoryStream(inData)) { using (BinaryReader br = new BinaryReader(ms)) { this.Flags = (MaterialFlags)br.ReadUInt32(); this.Shader = (ShaderTypes)br.ReadUInt32(); this.BlendMode = (BlendingMode)br.ReadUInt32(); this.FirstTextureOffset = br.ReadUInt32(); this.FirstColour = br.ReadRGBA(); this.FirstFlags = (MaterialFlags)br.ReadUInt32(); this.SecondTextureOffset = br.ReadUInt32(); this.SecondColour = br.ReadRGBA(); this.GroundType = new UInt32ForeignKey("TerrainType", "ID", br.ReadUInt32()); this.ThirdTextureOffset = br.ReadUInt32(); this.BaseDiffuseColour = br.ReadRGBA(); this.ThirdFlags = (MaterialFlags)br.ReadUInt32(); this.RuntimeData1 = br.ReadUInt32(); this.RuntimeData2 = br.ReadUInt32(); this.RuntimeData3 = br.ReadUInt32(); this.RuntimeData4 = br.ReadUInt32(); } } }
/// <summary> /// Gets shader's source code for color coded picking. /// </summary> /// <param name="shaderType"></param> /// <returns></returns> public static string GetShaderSource(ShaderTypes shaderType) { string result = string.Empty; switch (shaderType) { case ShaderTypes.VertexShader: if (vertexShader == null) { vertexShader = ManifestResourceLoader.LoadTextFile(@"PickingShader.vert"); } result = vertexShader; break; case ShaderTypes.FragmentShader: if (fragmentShader == null) { fragmentShader = ManifestResourceLoader.LoadTextFile(@"PickingShader.frag"); } result = fragmentShader; break; default: throw new NotImplementedException(); } return(result); }
/// <summary> /// Gets shader's source code for color coded picking. /// </summary> /// <param name="shaderType"></param> /// <returns></returns> public static string GetShaderSource(ShaderTypes shaderType) { string result = string.Empty; switch (shaderType) { case ShaderTypes.VertexShader: if (vertexShader == null) { vertexShader = ManifestResourceLoader.LoadTextFile(@"PickingShader.vert"); } result = vertexShader; break; case ShaderTypes.FragmentShader: if (fragmentShader == null) { fragmentShader = ManifestResourceLoader.LoadTextFile(@"PickingShader.frag"); } result = fragmentShader; break; default: throw new NotImplementedException(); } return result; }
public MOMT(BinaryReader br, uint version) { if (version == 14) { Version = br.ReadUInt32(); } Flags = br.ReadEnum <MOMT_Flags>(); if (version != 14) { Shader = br.ReadEnum <ShaderTypes>(); } BlendMode = br.ReadEnum <BlendMode>(); DiffuseNameIndex = br.ReadUInt32(); SidnColor = br.ReadStruct <Common.CImVector>(); FrameSidnColor = br.ReadStruct <Common.CImVector>(); EnvNameIndex = br.ReadUInt32(); DiffColor = br.ReadStruct <Common.CImVector>(); GroundType = br.ReadUInt32(); if (version == 14) { br.BaseStream.Position += 8; } else { UnknownTexture = br.ReadUInt32(); UnknownColor = br.ReadStruct <Common.CImVector>(); UnknownFlags = br.ReadEnum <MOMT_Flags>(); br.BaseStream.Position += 16; } }
internal Effect GetStaticEffect(ShaderTypes type) { if (_shaders.ContainsKey(type)) { return(_shaders[type]); } throw new Exception($"Shader not found: ShaderTypes::{type}"); }
public Effect GetEffect(ShaderTypes type) { if (_shaders.ContainsKey(type)) { return(_shaders[type].Clone()); } throw new Exception($"Shader not found: ShaderTypes::{type}"); }
/// <summary> /// Creates a shader. /// </summary> /// <param name="gl"></param> /// <param name="type"></param> /// <param name="shaderCode"></param> private void CreateShader(OpenGL gl, ShaderTypes type, string shaderCode) { var id = gl.CreateShader((uint)type); gl.ShaderSource(id, shaderCode); gl.CompileShader(id); ShaderIds.Add(type, id); }
/// <summary> /// Deletes the shader and removes it from the ShaderIds-Dictionary. /// </summary> /// <param name="gl"></param> /// <param name="type"></param> public void DeleteShader(OpenGL gl, ShaderTypes type) { var shader = ShaderIds[type]; gl.DeleteShader(shader); ShaderIds.Remove(type); }
public ShaderModel(Shader shader, byte[] code, ShaderTypes shaderType) #endif : base(shader) { try { #if WINRT || WP8 this.shader = shader; #endif var video = shader.FindParentOrSelfWithException <Video>(); com = new ShaderModelCom(); #if WIN32 string shaderLvl = ""; switch (shaderVersion) { case ShaderVersions.HLSL_2_0: shaderLvl = "_4_0_level_9_1"; break; case ShaderVersions.HLSL_2_a: shaderLvl = "_4_0_level_9_2"; break; case ShaderVersions.HLSL_3_0: shaderLvl = "_4_0_level_9_3"; break; case ShaderVersions.HLSL_4_0: shaderLvl = "_4_0"; break; case ShaderVersions.HLSL_4_1: shaderLvl = "_4_1"; break; case ShaderVersions.HLSL_5_0: shaderLvl = "_5_0"; break; default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } string errorText; var error = com.Init(video.com, code, code.Length, shaderType.ToString().ToLower() + shaderLvl, out errorText); #else var error = com.Init ( video.com, code, code.Length, shaderType == ShaderTypes.VS ? shader.vsVariableBufferSize : shader.psVariableBufferSize, shaderType == ShaderTypes.VS ? shader.vsResourceCount : shader.psResourceCount ); #endif switch (error) { #if WIN32 case ShaderModelErrors.CompileCode: Debug.ThrowError("ShaderModel", "Shader compiler error: " + errorText); break; #endif case ShaderModelErrors.VariableBuffer: Debug.ThrowError("ShaderModel", "Failed to create VariableBuffer"); break; case ShaderModelErrors.Reflect: Debug.ThrowError("ShaderModel", "Failed to Reflect the shader"); break; } } catch (Exception e) { Dispose(); throw e; } }
private void DefaultAssetShader() { GUILayout.Label("Default Asset Shader", bigLabel); GUILayout.Space(20); GUILayout.Label("This is the shader variant that will be assinged by default to Sprites and UI Images when the asset component is added", EditorStyles.boldLabel); bool isUrp = false; Shader temp = Resources.Load("AllIn1Urp2dRenderer", typeof(Shader)) as Shader; if (temp != null) { isUrp = true; } shaderTypes = (ShaderTypes)PlayerPrefs.GetInt("allIn1DefaultShader"); int previousShaderType = (int)shaderTypes; shaderTypes = (ShaderTypes)EditorGUILayout.EnumPopup(shaderTypes, GUILayout.MaxWidth(200)); if (previousShaderType != (int)shaderTypes) { if (!isUrp && shaderTypes == ShaderTypes.Urp2dRenderer) { showUrpWarning = true; warningTime = EditorApplication.timeSinceStartup + 5; } else { PlayerPrefs.SetInt("allIn1DefaultShader", (int)shaderTypes); showUrpWarning = false; } } if (warningTime < EditorApplication.timeSinceStartup) { showUrpWarning = false; } if (isUrp) { showUrpWarning = false; } if (!isUrp && !showUrpWarning && shaderTypes == ShaderTypes.Urp2dRenderer) { showUrpWarning = true; warningTime = EditorApplication.timeSinceStartup + 5; shaderTypes = ShaderTypes.Default; PlayerPrefs.SetInt("allIn1DefaultShader", (int)shaderTypes); } if (showUrpWarning) { EditorGUILayout.HelpBox( "You can't set the URP 2D Renderer variant since you didn't import the URP package available in the asset root folder (SEE DOCUMENTATION)", MessageType.Error, true); } }
public Effect LoadEffect(string fileName, ShaderTypes type) { if (_shaders.ContainsKey(type)) { return(_shaders[type]); } var effect = Content.Load <Effect>(fileName); _shaders[type] = effect; return(effect); }
public void Attach(ShaderTypes shaderType, string filename) { switch (shaderType) { case ShaderTypes.Vertex: vertexShader = Load(filename, GL_VERTEX_SHADER); break; case ShaderTypes.Geometry: geometryShader = Load(filename, GL_GEOMETRY_SHADER); break; case ShaderTypes.Fragment: fragmentShader = Load(filename, GL_FRAGMENT_SHADER); break; } }
public string GetShaderInfoLog(OpenGL gl, ShaderTypes type) { // Get the info log length. int[] infoLength = GetShaderResult(gl, type, GetShaderActions.GL_INFO_LOG_LENGTH, 1); int bufSize = infoLength[0]; // Get the compile info. StringBuilder il = new StringBuilder(bufSize); gl.GetShaderInfoLog(ShaderIds[type], bufSize, IntPtr.Zero, il); return(il.ToString()); }
public UOResource(byte[] raw, ShaderTypes type, bool _isLegacy) { DDSImage img = new DDSImage(raw); _ddsData.width = img.images[0].Width; _ddsData.height = img.images[0].Height; _ddsData.format = img.format; _ddsData.rawData = ImageToByte2(img.images[0]); switch (type) { case ShaderTypes.Sprite: stype = "Sprites/Default"; break; case ShaderTypes.Terrain: stype = "Diffuse"; break; default: stype = "Sprites/Default"; break; } }
public static UOResource getResource(TextureImageInfo tileartTextureInfo, ShaderTypes stype) { //FAST search if (textures.ContainsKey(tileartTextureInfo.textureIDX)) { //TODO: references++ return(textures[tileartTextureInfo.textureIDX]); } //Get the string from stringDictionary if (tileartTextureInfo.textureIDX >= stringDictionary.count) { UOConsole.Fatal("String {0} not found in dictionary.", tileartTextureInfo.textureIDX); return(null); } string tga = stringDictionary.values[tileartTextureInfo.textureIDX]; //Replace extension int start = (tga.LastIndexOf("\\") == -1) ? 0 : (tga.LastIndexOf("\\") + 1); int end = tga.IndexOf("_"); if (end == -1) { UOConsole.Fatal("no descr in: {0} .. trying with extension", tga); tga = tga.Replace(".tga", ""); end = tga.Length; } //UOConsole.Fatal("{0} {1} {2}", tga, start, end); string toHash = tga.Substring(start, end - start) + ".dds"; toHash = toHash.ToLower(); toHash = "build/worldart/" + toHash; //Get the file from Texture.uop ulong tehHash = HashDictionary.HashFileName(toHash); if (!uopHashes.textureHashes.ContainsKey(tehHash)) { UOConsole.Fatal("string {0} not found in textureHashes - tga: {1}", toHash, tga); return(null); } uopMapping_t map = uopHashes.textureHashes[tehHash]; MythicPackage tex = new MythicPackage(fileDirectory + "texture.uop"); byte[] raw = tex.Blocks[map.block].Files[map.file].Unpack(tex.FileInfo.FullName); UOResource res = new UOResource(raw, stype); textures.Add(tileartTextureInfo.textureIDX, res); return(res); }
public ShaderModel(Shader shader, byte[] code, ShaderTypes shaderType) #endif : base(shader) { try { #if WINRT || WP8 this.shader = shader; #endif var video = shader.FindParentOrSelfWithException<Video>(); com = new ShaderModelCom(); #if WIN32 string shaderLvl = ""; switch (shaderVersion) { case ShaderVersions.HLSL_2_0: shaderLvl = "_4_0_level_9_1"; break; case ShaderVersions.HLSL_2_a: shaderLvl = "_4_0_level_9_2"; break; case ShaderVersions.HLSL_3_0: shaderLvl = "_4_0_level_9_3"; break; case ShaderVersions.HLSL_4_0: shaderLvl = "_4_0"; break; case ShaderVersions.HLSL_4_1: shaderLvl = "_4_1"; break; case ShaderVersions.HLSL_5_0: shaderLvl = "_5_0"; break; default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } string errorText; var error = com.Init(video.com, code, code.Length, shaderType.ToString().ToLower() + shaderLvl, out errorText); #else var error = com.Init ( video.com, code, code.Length, shaderType == ShaderTypes.VS ? shader.vsVariableBufferSize : shader.psVariableBufferSize, shaderType == ShaderTypes.VS ? shader.vsResourceCount : shader.psResourceCount ); #endif switch (error) { #if WIN32 case ShaderModelErrors.CompileCode: Debug.ThrowError("ShaderModel", "Shader compiler error: " + errorText); break; #endif case ShaderModelErrors.VariableBuffer: Debug.ThrowError("ShaderModel", "Failed to create VariableBuffer"); break; case ShaderModelErrors.Reflect: Debug.ThrowError("ShaderModel", "Failed to Reflect the shader"); break; } } catch (Exception e) { Dispose(); throw e; } }
public void Attach(ShaderTypes shaderType, string filename) { uint id = Load(filename, (uint)shaderType); switch (shaderType) { case ShaderTypes.Vertex: vertexShader = id; break; case ShaderTypes.TessellationControl: tesselationControlShader = id; break; case ShaderTypes.TessellationEvaluation: tesselationEvaluationShader = id; break; case ShaderTypes.Geometry: geometryShader = id; break; case ShaderTypes.Fragment: fragmentShader = id; break; } }
private void SetCurrentShaderType(AllIn1Shader myScript) { string shaderName = ""; SpriteRenderer sr = myScript.GetComponent <SpriteRenderer>(); if (sr != null) { Renderer r = myScript.GetComponent <Renderer>(); if (r.sharedMaterial != null) { shaderName = r.sharedMaterial.shader.name; } } else { Image img = myScript.GetComponent <Image>(); if (img != null) { shaderName = img.material.shader.name; } } shaderName = shaderName.Replace("AllIn1SpriteShader/", ""); if (shaderName.Equals("AllIn1SpriteShader")) { shaderTypes = ShaderTypes.Default; } else if (shaderName.Equals("AllIn1SpriteShaderScaledTime")) { shaderTypes = ShaderTypes.ScaledTime; } else if (shaderName.Equals("AllIn1SpriteShaderUiMask")) { shaderTypes = ShaderTypes.MaskedUI; } }
public static UOResource getResource(TextureImageInfo tileartTextureInfo, ShaderTypes stype) { //FAST search if (textures.ContainsKey(tileartTextureInfo.textureIDX)) { //TODO: references++ return textures[tileartTextureInfo.textureIDX]; } //Get the string from stringDictionary if (tileartTextureInfo.textureIDX >= stringDictionary.count) { UOConsole.Fatal("String {0} not found in dictionary.", tileartTextureInfo.textureIDX); return null; } string tga = stringDictionary.values[tileartTextureInfo.textureIDX]; //Replace extension int start = (tga.LastIndexOf("\\") == -1) ? 0 : (tga.LastIndexOf("\\") + 1); int end = tga.IndexOf("_"); if (end == -1) { UOConsole.Fatal("no descr in: {0} .. trying with extension", tga); tga = tga.Replace(".tga",""); end = tga.Length; } //UOConsole.Fatal("{0} {1} {2}", tga, start, end); string toHash = tga.Substring(start, end - start) + ".dds"; toHash = toHash.ToLower(); toHash = "build/worldart/" + toHash; //Get the file from Texture.uop ulong tehHash = HashDictionary.HashFileName(toHash); if (!uopHashes.textureHashes.ContainsKey(tehHash)) { UOConsole.Fatal("string {0} not found in textureHashes - tga: {1}", toHash, tga); return null; } uopMapping_t map = uopHashes.textureHashes[tehHash]; MythicPackage tex = new MythicPackage(fileDirectory + "texture.uop"); byte[] raw = tex.Blocks[map.block].Files[map.file].Unpack(tex.FileInfo.FullName); UOResource res = new UOResource(raw, stype); textures.Add(tileartTextureInfo.textureIDX, res); return res; }
internal Shader getShader(ShaderTypes shaderType) { return shaders[(int)shaderType]; }
public UOResource(byte[] raw, ShaderTypes type) : this(raw, type, false) { }
public static Color ColorFromFloat3(ShaderTypes.float3 f3) { return Color.FromArgb((int)(f3.x * 255), (int)(f3.y * 255), (int)(f3.z * 255)); }
public ShaderModel(Shader shader, string code, ShaderTypes shaderType, ShaderVersions shaderVersion)
public Shader(ShaderTypes t, string code) { Code = code ?? throw new ArgumentNullException(nameof(code)); Type = t; Create(); }
public int[] GetShaderResult(OpenGL gl, ShaderTypes shaderType, GetShaderActions action, uint expectedLength) { int[] parameters = new int[expectedLength]; gl.GetShader(ShaderIds[shaderType], (uint)action, parameters); return parameters; }
public bool GetShaderCompileStatus(OpenGL gl, ShaderTypes type) { var parameters = GetShaderResult(gl, type, GetShaderActions.GL_COMPILE_STATUS, 1); return(parameters[0] == OpenGL.GL_TRUE); }
public unsafe ShaderModel(IShader shader, string code, ShaderVersions shaderVersion, ShaderTypes shaderType, ShaderFloatingPointQuality quality) : base(shader) { try { Shader = GL.CreateShader((shaderType == ShaderTypes.VS) ? GL.VERTEX_SHADER : GL.FRAGMENT_SHADER); if (Shader == 0) { Debug.ThrowError("ShaderModel", string.Format("Failed to create {0} shader", (shaderType == ShaderTypes.VS) ? "vs": "ps")); } #if iOS || ANDROID || NaCl code = getQualityText(quality) + Environment.NewLine + code; #endif string shaderLvl = ""; switch (shaderVersion) { #if iOS || ANDROID || NaCl || RPI case ShaderVersions.GLSL_1_00: shaderLvl = "100"; break; #else case ShaderVersions.GLSL_1_10: shaderLvl = "110"; break; case ShaderVersions.GLSL_1_20: shaderLvl = "120"; break; case ShaderVersions.GLSL_1_30: shaderLvl = "130"; break; case ShaderVersions.GLSL_1_40: shaderLvl = "140"; break; case ShaderVersions.GLSL_1_50: shaderLvl = "150"; break; case ShaderVersions.GLSL_3_30: shaderLvl = "330"; break; #endif default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } code = "#version " + shaderLvl + Environment.NewLine + code; int codeLength = code.Length; fixed(byte *codeData = code.CastToBytes()) { byte *codeData2 = codeData; GL.ShaderSource(Shader, 1, &codeData2, &codeLength); GL.CompileShader(Shader); } int result = 0; GL.GetShaderiv(Shader, GL.COMPILE_STATUS, &result); if (result == 0) { int logLength = 0; GL.GetShaderiv(Shader, GL.INFO_LOG_LENGTH, &logLength); byte *logPtr = stackalloc byte[logLength]; GL.GetShaderInfoLog(Shader, logLength, &result, logPtr); byte[] log = new byte[logLength]; System.Runtime.InteropServices.Marshal.Copy(new IntPtr(logPtr), log, 0, logLength); Debug.ThrowError("ShaderModel", string.Format("{0} Shader compile error: {1}", shaderType, System.Text.ASCIIEncoding.ASCII.GetString(log))); } Video.checkForError(); } catch (Exception e) { Dispose(); throw e; } }
public ModelMaterial(byte[] inData) { using (MemoryStream ms = new MemoryStream(inData)) { using (BinaryReader br = new BinaryReader(ms)) { this.Flags = (MaterialFlags) br.ReadUInt32(); this.Shader = (ShaderTypes) br.ReadUInt32(); this.BlendMode = (BlendingMode) br.ReadUInt32(); this.FirstTextureOffset = br.ReadUInt32(); this.FirstColour = br.ReadRGBA(); this.FirstFlags = (MaterialFlags)br.ReadUInt32(); this.SecondTextureOffset = br.ReadUInt32(); this.SecondColour = br.ReadRGBA(); this.GroundType = new UInt32ForeignKey("TerrainType", "ID", br.ReadUInt32()); this.ThirdTextureOffset = br.ReadUInt32(); this.BaseDiffuseColour = br.ReadRGBA(); this.ThirdFlags = (MaterialFlags)br.ReadUInt32(); this.RuntimeData1 = br.ReadUInt32(); this.RuntimeData2 = br.ReadUInt32(); this.RuntimeData3 = br.ReadUInt32(); this.RuntimeData4 = br.ReadUInt32(); } } }
public void AddProgram(string code, ShaderTypes type) { RenderManager.Renderer.AddShader(id, code, type); }
internal Shader getShader(ShaderTypes shaderType) { return(shaders[(int)shaderType]); }
public int[] GetShaderResult(OpenGL gl, ShaderTypes shaderType, GetShaderActions action, uint expectedLength) { int[] parameters = new int[expectedLength]; gl.GetShader(ShaderIds[shaderType], (uint)action, parameters); return(parameters); }
public override void OnInspectorGUI() { Texture2D imageInspector = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/AllIn1SpriteShader/Textures/CustomEditorImage.png", typeof(Texture2D)); if (imageInspector) { Rect rect; float imageHeight = imageInspector.height; float imageWidth = imageInspector.width; float aspectRatio = imageHeight / imageWidth; rect = GUILayoutUtility.GetRect(imageHeight, aspectRatio * Screen.width); EditorGUI.DrawTextureTransparent(rect, imageInspector); } AllIn1Shader myScript = (AllIn1Shader)target; if (shaderTypes == ShaderTypes.Invalid) { SetCurrentShaderType(myScript); } if (GUILayout.Button("Deactivate All Effects")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).ClearAllKeywords(); } } if (GUILayout.Button("New Clean Material")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).TryCreateNew(); } } if (GUILayout.Button("Create New Material With Same Properties (SEE DOC)")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).MakeCopy(); } } if (GUILayout.Button("Save Material To Folder (SEE DOC)")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).SaveMaterial(); } } if (GUILayout.Button("Apply Material To All Children")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).ApplyMaterialToHierarchy(); } } EditorGUILayout.BeginHorizontal(); { GUILayout.Label("Change Shader Type:"); int previousShaderType = (int)shaderTypes; shaderTypes = (ShaderTypes)EditorGUILayout.EnumPopup(shaderTypes); if (previousShaderType != (int)shaderTypes) { Debug.Log(myScript.gameObject.name + " shader has been changed to: " + shaderTypes); myScript.SetSceneDirty(); SpriteRenderer sr = myScript.GetComponent <SpriteRenderer>(); if (sr != null) { Renderer r = myScript.GetComponent <Renderer>(); if (r.sharedMaterial != null) { if (shaderTypes == ShaderTypes.Default) { r.sharedMaterial.shader = Resources.Load("AllIn1SpriteShader", typeof(Shader)) as Shader; } else if (shaderTypes == ShaderTypes.ScaledTime) { r.sharedMaterial.shader = Resources.Load("AllIn1SpriteShaderScaledTime", typeof(Shader)) as Shader; } else if (shaderTypes == ShaderTypes.MaskedUI) { r.sharedMaterial.shader = Resources.Load("AllIn1SpriteShaderUiMask", typeof(Shader)) as Shader; } else { SetCurrentShaderType(myScript); } } } else { Image img = myScript.GetComponent <Image>(); if (img.material != null) { if (shaderTypes == ShaderTypes.Default) { img.material.shader = Resources.Load("AllIn1SpriteShader", typeof(Shader)) as Shader; } else if (shaderTypes == ShaderTypes.ScaledTime) { img.material.shader = Resources.Load("AllIn1SpriteShaderScaledTime", typeof(Shader)) as Shader; } else if (shaderTypes == ShaderTypes.MaskedUI) { img.material.shader = Resources.Load("AllIn1SpriteShaderUiMask", typeof(Shader)) as Shader; } else { SetCurrentShaderType(myScript); } } } } } EditorGUILayout.EndHorizontal(); EditorGUILayout.Space(); if (GUILayout.Button("Sprite Atlas Auto Setup")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).ToggleSetAtlasUvs(true); } } if (GUILayout.Button("Remove Sprite Atlas Configuration")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).ToggleSetAtlasUvs(false); } } EditorGUILayout.Space(); if (GUILayout.Button("REMOVE COMPONENT AND MATERIAL")) { for (int i = 0; i < targets.Length; i++) { (targets[i] as AllIn1Shader).CleanMaterial(); } for (int i = targets.Length - 1; i >= 0; i--) { DestroyImmediate(targets[i] as AllIn1Shader); } } }
public static Color ColorFromFloat4(ShaderTypes.float4 f4) { return Color.FromArgb((int)(f4.x * 255), (int)(f4.y * 255), (int)(f4.z * 255)); }
public ShaderModel(IDisposableResource parent, string code, ShaderVersions shaderVersion, ShaderTypes shaderType) : base(parent) { try { var video = parent.FindParentOrSelfWithException <Video>(); string shaderLvl = ""; switch (shaderVersion) { case ShaderVersions.HLSL_2_0: shaderLvl = "_2_0"; break; case ShaderVersions.HLSL_2_a: shaderLvl = "_2_a"; break; case ShaderVersions.HLSL_3_0: shaderLvl = "_3_0"; break; default: Debug.ThrowError("ShaderModel", "Unsuported ShaderVersion: " + shaderVersion); break; } string shaderVersionType = shaderType.ToString().ToLower() + shaderLvl; com = new ShaderModelCom(); var codePtr = Marshal.StringToHGlobalAnsi(code); var shaderVersionTypePtr = Marshal.StringToHGlobalAnsi(shaderVersionType); string errorText; var error = com.Init(video.com, codePtr, code.Length, shaderVersionTypePtr, out errorText); if (codePtr != IntPtr.Zero) { Marshal.FreeHGlobal(codePtr); } if (shaderVersionTypePtr != IntPtr.Zero) { Marshal.FreeHGlobal(shaderVersionTypePtr); } switch (error) { case ShaderModelErrors.Compile: Debug.ThrowError("ShaderModel", string.Format("Failed to compile {0} shader: Errors: {1}", shaderType == ShaderTypes.VS ? "vs" : "ps", errorText)); break; } } catch (Exception e) { Dispose(); throw e; } }
public bool GetShaderCompileStatus(OpenGL gl, ShaderTypes type) { var parameters = GetShaderResult(gl, type, GetShaderActions.GL_COMPILE_STATUS, 1); return parameters[0] == OpenGL.GL_TRUE; }
public string GetShaderInfoLog(OpenGL gl, ShaderTypes type) { // Get the info log length. int[] infoLength = GetShaderResult(gl, type, GetShaderActions.GL_INFO_LOG_LENGTH, 1); int bufSize = infoLength[0]; // Get the compile info. StringBuilder il = new StringBuilder(bufSize); gl.GetShaderInfoLog(ShaderIds[type], bufSize, IntPtr.Zero, il); return il.ToString(); }