C# ShaderType.ToString方法代码示例

		public int initShader(ShaderType shaderTypeToUse, string shaderProgram) {
			int shaderID = 0;

			ErrorCode iErrorCodePrior = GL.GetError();
			if ( iErrorCodePrior != ErrorCode.NoError ) {
				throw new Exception ("Warning: An existing problem with the OpenGL state was found. Error code " + iErrorCodePrior.ToString() + ". This means an invalid call was made and not checked for before this part of the program was run.");
			}
			
			shaderID = GL.CreateShader(shaderTypeToUse);
			ErrorCode iErrorCode = GL.GetError();
			if ( iErrorCode != ErrorCode.NoError ) {
				throw new Exception ("There was a problem creating a shader of type " + shaderTypeToUse.ToString() + ". The error was '" + iErrorCode.ToString() + "'.");
			}
			
			if ( 0 == shaderID ) {
				throw new Exception ("There was a problem creating a shader of type " + shaderTypeToUse.ToString() + ". We were unable to query for the GL Error code.");
			}
			
			if ( string.Empty == shaderProgram ) {
				throw new Exception ("The shaderProgram property of ShaderCreate can not be empty. Please review the configuration");	
			}

			GL.ShaderSource(shaderID, shaderProgram);
			ErrorCode iErrorCode2 = GL.GetError();
			
			if ( iErrorCode2 != ErrorCode.NoError ) {
				switch (iErrorCode2) {
					case ErrorCode.InvalidOperation:
						throw new Exception ("Setting the shader source had a problem. The current shader compiler is not supported OR the shader ID, " + shaderID + ", is not a shader object (the handle ID is to something other than a shader.");
					case ErrorCode.InvalidValue:
						throw new Exception ("Setting the shader source had a problem. The shaderID provide, " + shaderID + ", was not generated by OpenGL or the shader program was empty (count of string length was 0). Please contact the developers as this should never happen.");
					default:
						throw new Exception ("Setting the shader source had a problem. . The error was '" + iErrorCode2.ToString() + "'.");
				}
					
			}
			
			GL.CompileShader(shaderID);
			
			string logInfo = GL.GetShaderInfoLog(shaderID);
			
			if ( string.Empty != logInfo ) {
				throw new Exception ("There was a problem compiling a shading program. Problems as follows '" + logInfo + "'. If the code looks fine, are you using the right shader type? For example, maybe you passed fragment code to a vertex shader?");	
			}
			
			return shaderID;
			
		}

        int LoadShader(ShaderType type, string source)
        {
            int shader = GL.CreateShader(type);
            if (shader == 0)
                throw new InvalidOperationException("Unable to create shader");

            int length = 0;
            GL.ShaderSource(shader, 1, new string[] { source }, (int[])null);
            GL.CompileShader(shader);

            int compiled = 0;
            GL.GetShader(shader, ShaderParameter.CompileStatus, out compiled);
            if (compiled == 0)
            {
                length = 0;
                GL.GetShader(shader, ShaderParameter.InfoLogLength, out length);
                if (length > 0)
                {
                    var log = new StringBuilder(length);
                    GL.GetShaderInfoLog(shader, length, out length, log);
                    Console.WriteLine("Couldn't compile shader: " + log.ToString());
                }

                GL.DeleteShader(shader);
                throw new InvalidOperationException("Unable to compile shader of type : " + type.ToString());
            }

            return shader;
        }

 public void Compile(string sShader, ShaderType type)
 {
     isLinked = false;
     int shaderObject = GL.CreateShader(type);
     if (0 == shaderObject) throw new ShaderException(type.ToString(), "Could not create shader object", string.Empty, sShader);
     // Compile vertex shader
     GL.ShaderSource(shaderObject, sShader);
     GL.CompileShader(shaderObject);
     int status_code;
     GL.GetShader(shaderObject, ShaderParameter.CompileStatus, out status_code);
     LastLog = GL.GetShaderInfoLog(shaderObject);
     if (1 != status_code)
     {
         throw new ShaderException(type.ToString(), "Error compiling shader", LastLog, sShader);
     }
     GL.AttachShader(m_ProgramID, shaderObject);
     //shaderIDs.Add(shaderObject);
 }

 public void AddShader(ShaderType type, String source)
 {
     _shaders[type] = GL.CreateShader(type);
     GL.ShaderSource(_shaders[type], source);
     GL.CompileShader(_shaders[type]);
     if (OnMessage != null) OnMessage(GL.GetShaderInfoLog(_shaders[type]));
     int compileResult;
     GL.GetShader(_shaders[type], ShaderParameter.CompileStatus, out compileResult);
     if (compileResult != 1)
     {
         if (OnMessage != null) OnMessage("Compile Error:" + type.ToString());
     }
     if (OnMessage != null) OnMessage("Compiled");
     GL.AttachShader(Program, _shaders[type]);
 }

        public int Load(SceneNode _node, ShaderType type)
        {
            BaseShader shader = null;
            switch (type)
            {
                case ShaderType.Sky:
                    if (Reference.Viewer.IsDrawSky)
                    {
                        shader = new Sky(Reference.Viewer, ParentNode);
                    }
                    break;

                case ShaderType.Sea:
                    if (Reference.Viewer.IsDrawSea)
                    {
                        if (Reference.Viewer.SeaQuality == Viewer.ShaderLevelType.Low)
                            shader = new Sea(Reference.Viewer, ParentNode);
                    }
                    break;

                case ShaderType.AdvancedSea:
                    if (Reference.Viewer.IsDrawSea)
                    {
                        if (Reference.Viewer.SeaQuality == Viewer.ShaderLevelType.High)
                            shader = new AdvancedSea(Reference.Viewer, ParentNode);
                    }
                    break;

                case ShaderType.Shadow:
                    if (Reference.Viewer.IsDrawSky)
                    {
                    }
                    break;
            }

            int res = -1;
            if (shader != null)
            {
                // Load shader.
                //Reference.Device.FileSystem.WorkingDirectory = Util.ApplicationDataDirectory + @"\media";
                res = shader.Load();
                if (res > 0)
                {
                    if (shaders.ContainsKey(type))
                    {
                        Reference.Log.Debug("[SHADER]: " + type.ToString() + " Read multi.");
                    }
                    else
                    {
                        lock (shaders)
                        {
                            shaders.Add(type, shader);
                        }

                        lock (shaderIndex)
                        {
                            shaderIndex.Add(type, res);
                        }
                    }
                }
                else
                {
                    Reference.Log.Debug("[SHADER]: " + type.ToString() + " Shader don't load.");
                }
            }

            return res;
        }

        protected void CompileShader(ShaderType type, string[] source)
        {
            _shaderId = GL.CreateShader(type);
            int[] lens = new int[source.Length];
            for (int i = 0; i < lens.Length; i++)
                lens[i] = -1;
            GL.ShaderSource(ID, source.Length, source, ref lens[0]);
            GL.CompileShader(ID);

            int status;
            GL.GetShader(ID, ShaderParameter.CompileStatus, out status);
            if (status == 0)
                throw new GraphicsException(
                    String.Format("Error compiling {0} shader: {1}", type.ToString(), GL.GetShaderInfoLog(ID)));
        }

        private void checkCompilationErrors(int shaderID, ShaderType type)
        {
            int compileStatus = 0;
            GL.GetShader(shaderID, ShaderParameter.CompileStatus, out compileStatus);

            if (compileStatus == COMPILE_ERROR)
            {
                //Shader compilation failed.  Output compilation error to console and throw new exception
                string shaderInfo = String.Empty;
                GL.GetShaderInfoLog(shaderID, out shaderInfo);

                Console.WriteLine(String.Format("ERROR::SHADER: Compile-time error: Type: {0}\n{1}", type.ToString(), shaderInfo));

                throw new ShaderCompilationErrorException(
                    String.Format("Shader #{0} ({1}) failed to compile.  Check debug console for error message.",
                    shaderID, type.ToString()));
            }
        }

        /// <summary>
        /// Build the shaders
        /// </summary>
        private int LoadShader(ShaderType type, string source)
        {
            int shader = GL20.CreateShader (type);

            if (shader == 0)
                throw new InvalidOperationException (string.Format (
                    "Unable to create shader: {0}", GL20.GetError ())
                );

            // Load the shader source
            int length = 0;
            GL20.ShaderSource (shader, 1, new string[] {source}, (int[])null);

            // Compile the shader
            GL20.CompileShader (shader);

            int compiled = 0;
            GL20.GetShader (shader, ShaderParameter.CompileStatus, out compiled);
            if (compiled == 0) {
                length = 0;
                GL20.GetShader (shader, ShaderParameter.InfoLogLength, out length);
                if (length > 0) {
                    var log = new StringBuilder (length);
                    GL20.GetShaderInfoLog (shader, length, out length, log);
            #if DEBUG
                        Console.WriteLine("GL2" + log.ToString ());
            #endif
                }

                GL20.DeleteShader (shader);
                throw new InvalidOperationException ("Unable to compile shader of type : " + type.ToString ());
            }

            return shader;
        }