Ejemplo n.º 1
0
        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();
                }
            }
        }
Ejemplo n.º 2
0
        /// <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);
        }
Ejemplo n.º 3
0
        /// <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;
        }
Ejemplo n.º 4
0
        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;
            }
        }
Ejemplo n.º 5
0
 internal Effect GetStaticEffect(ShaderTypes type)
 {
     if (_shaders.ContainsKey(type))
     {
         return(_shaders[type]);
     }
     throw new Exception($"Shader not found: ShaderTypes::{type}");
 }
Ejemplo n.º 6
0
 public Effect GetEffect(ShaderTypes type)
 {
     if (_shaders.ContainsKey(type))
     {
         return(_shaders[type].Clone());
     }
     throw new Exception($"Shader not found: ShaderTypes::{type}");
 }
Ejemplo n.º 7
0
        /// <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);
        }
Ejemplo n.º 8
0
        /// <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);
        }
Ejemplo n.º 9
0
        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;
            }
        }
Ejemplo n.º 10
0
    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);
        }
    }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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;
            }
        }
Ejemplo n.º 13
0
        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());
        }
Ejemplo n.º 14
0
		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;
			}
		}
Ejemplo n.º 15
0
        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);
        }
Ejemplo n.º 16
0
		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;
			}
		}
Ejemplo n.º 17
0
        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;
            }
        }
Ejemplo n.º 18
0
        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;
            }
        }
Ejemplo n.º 19
0
    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;
        }
    }
Ejemplo n.º 20
0
		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;
		}
Ejemplo n.º 21
0
 internal Shader getShader(ShaderTypes shaderType)
 {
     return shaders[(int)shaderType];
 }
Ejemplo n.º 22
0
 public UOResource(byte[] raw, ShaderTypes type) :
     this(raw, type, false)
 {
 }
Ejemplo n.º 23
0
 public static Color ColorFromFloat3(ShaderTypes.float3 f3)
 {
     return Color.FromArgb((int)(f3.x * 255), (int)(f3.y * 255), (int)(f3.z * 255));
 }
Ejemplo n.º 24
0
		public ShaderModel(Shader shader, string code, ShaderTypes shaderType, ShaderVersions shaderVersion)
Ejemplo n.º 25
0
 public ShaderModel(Shader shader, string code, ShaderTypes shaderType, ShaderVersions shaderVersion)
Ejemplo n.º 26
0
 public Shader(ShaderTypes t, string code)
 {
     Code = code ?? throw new ArgumentNullException(nameof(code));
     Type = t;
     Create();
 }
Ejemplo n.º 27
0
 /// <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);
 }
Ejemplo n.º 28
0
 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;
 }
Ejemplo n.º 29
0
        public bool GetShaderCompileStatus(OpenGL gl, ShaderTypes type)
        {
            var parameters = GetShaderResult(gl, type, GetShaderActions.GL_COMPILE_STATUS, 1);

            return(parameters[0] == OpenGL.GL_TRUE);
        }
Ejemplo n.º 30
0
        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;
            }
        }
Ejemplo n.º 31
0
        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();
                }
            }
        }
Ejemplo n.º 32
0
 public void AddProgram(string code, ShaderTypes type)
 {
     RenderManager.Renderer.AddShader(id, code, type);
 }
Ejemplo n.º 33
0
 internal Shader getShader(ShaderTypes shaderType)
 {
     return(shaders[(int)shaderType]);
 }
Ejemplo n.º 34
0
 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);
 }
Ejemplo n.º 35
0
 public void AddProgram(string code, ShaderTypes type)
 {
     RenderManager.Renderer.AddShader(id, code, type);
 }
Ejemplo n.º 36
0
    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);
            }
        }
    }
Ejemplo n.º 37
0
        /// <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);
        }
Ejemplo n.º 38
0
 public static Color ColorFromFloat4(ShaderTypes.float4 f4)
 {
     return Color.FromArgb((int)(f4.x * 255), (int)(f4.y * 255), (int)(f4.z * 255));
 }
Ejemplo n.º 39
0
        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;
            }
        }
Ejemplo n.º 40
0
        public bool GetShaderCompileStatus(OpenGL gl, ShaderTypes type)
        {
            var parameters = GetShaderResult(gl, type, GetShaderActions.GL_COMPILE_STATUS, 1);

            return parameters[0] == OpenGL.GL_TRUE;
        }
Ejemplo n.º 41
0
		public UOResource(byte[] raw, ShaderTypes type) :
			this(raw, type, false) {
		}
Ejemplo n.º 42
-1
        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();
        }