public SceneNode(SceneMesh pMesh, SceneProgram pProg, Vector3 nodePos, List<TextureBinding> texBindings)
 {
     m_pMesh = pMesh;
     m_pProg = pProg;
     m_texBindings = texBindings;
     m_nodeTm = new Transform();
     m_nodeTm.m_trans = nodePos;
 }
        private void ReadProgram(XmlElement progNode)
        {
            string pNameNode = progNode.GetAttribute("xml:id");
            string pVertexShaderNode = progNode.GetAttribute("vert");
            string pFragmentShaderNode = progNode.GetAttribute("frag");
            string pModelMatrixNode = progNode.GetAttribute("model-to-camera");

            PARSE_THROW(pNameNode, "Program found with no `xml:id` name specified.");
            PARSE_THROW(pVertexShaderNode, "Program found with no `vert` vertex shader specified.");
            PARSE_THROW(pFragmentShaderNode, "Program found with no `frag` fragment shader specified.");
            PARSE_THROW(pModelMatrixNode, "Program found with no model-to-camera matrix uniform name specified.");

            //Optional.
            string pNormalMatrixNode = progNode.GetAttribute("normal-model-to-camera");
            string pGeometryShaderNode = progNode.GetAttribute("geom");

            if(m_progs.Keys.Contains(pNameNode))
            {
                MessageBox.Show("The program named \"" + pNameNode + "\" already exists.");
            }

            List<int> shaders = new List<int>();
            int program = 0;
            string vertexShaderString = pVertexShaderNode.ToLower().Substring(0, pVertexShaderNode.Length - 5);
            var vertexShaderField = vertexShaders.GetType().GetField(vertexShaderString);
            string vertexShader = (string)vertexShaderField.GetValue(vertexShaders);

            string fragmentShaderString = pFragmentShaderNode.ToLower().Substring(0, pVertexShaderNode.Length - 5);
            var  fragmentShaderField = fragmentShaders.GetType().GetField(fragmentShaderString);
            string fragmentShader = (string)fragmentShaderField.GetValue(fragmentShaders);

            try
            {
                shaders.Add(Shader.compileShader(ShaderType.VertexShader, vertexShader));
                shaders.Add(Shader.compileShader(ShaderType.FragmentShader, fragmentShader));
                if(pGeometryShaderNode != "")
                    shaders.Add(Shader.compileShader(ShaderType.GeometryShader, "GEOMETRY_SHADER"));
                program = Shader.LinkProgram(shaders);
            }
            catch(Exception ex)
            {
                MessageBox.Show("Error creating program " + ex.ToString());
                foreach(int shader in shaders)
                {
                    GL.DeleteShader(shader);
                }
            }

            foreach (int shader in shaders)
            {
                GL.DeleteShader(shader);
            }

            int matrixLoc = GL.GetUniformLocation(program, pModelMatrixNode);
            if(matrixLoc == -1)
            {
                GL.DeleteProgram(program);
                MessageBox.Show("Could not find the matrix uniform " + pModelMatrixNode +
                    " in program " + pNameNode);
            }

            int normalMatLoc = -1;
            if(pNormalMatrixNode != "")
            {
                normalMatLoc = GL.GetUniformLocation(program, pNormalMatrixNode);
                if(normalMatLoc == -1)
                {
                    GL.DeleteProgram(program);
                    MessageBox.Show("Could not find the normal matrix uniform " + pNormalMatrixNode +
                        " in program " + pNameNode);
                }
            }

            m_progs[pNameNode] = new SceneProgram(program, matrixLoc, normalMatLoc);

            ReadProgramContents(program, progNode);
        }