public MaterialContent CreateMaterial(ContentProcessorContext context, Dictionary <string, object> parameters)
        {
            MaterialContent content = new MaterialContent()
            {
                Name = _name
            };

            int i = 0;

            foreach (PassTemplate template in _passes)
            {
                MaterialContent.Pass pass = new MaterialContent.Pass(string.IsNullOrEmpty(template.Name) ? string.Format("{0}_Pass_{1}", _name, i) : template.Name);
                pass.VertexShaderSources.AddRange(template.VertexShaders.Select(s => new ExternalReferenceContent <ShaderSourceContent>(s)));
                pass.FragmentShaderSources.AddRange(template.FragmentShaders.Select(s => new ExternalReferenceContent <ShaderSourceContent>(s)));

                foreach (UniformDefinition def in template.Variables)
                {
                    UniformValueContent value = null;
                    object o;
                    if (!parameters.TryGetValue(def.Name, out o))
                    {
                        foreach (string name in def.Aliases)
                        {
                            if (parameters.TryGetValue(name, out o))
                            {
                                break;
                            }
                        }
                    }
                    if (o != null)
                    {
                        value = GetAsUniformValueContent(def.Type, def.Name, o, context);
                    }

                    if (value == null) // no match, or not able to convert to uniform type
                    {
                        value = def.Value;
                    }

                    pass.Parameters[def.Name] = value;
                }

                foreach (UniformDefinition def in template.Constants)
                {
                    pass.Parameters[def.Name] = def.Value;
                }

                pass.ComparisonParameters = template.ComparisonParameters;

                i++;
                content.Passes.Add(pass);
            }

            return(content);
        }
        public override MaterialContent Process(object input, ContentProcessorContext context)
        {
            Dictionary <string, object> materialInput = (Dictionary <string, object>)input;
            MaterialContent             material      = new MaterialContent();

            if (materialInput.ContainsKey("name"))
            {
                material.Name = (string)materialInput["name"];
            }
            else
            {
                material.Name = string.Format("Material_{0}", _materialID++);
            }

            if (!materialInput.ContainsKey("passes"))
            {
                throw new ContentException("Material json definition is missing the required key passes.");
            }

            Dictionary <string, object> globalParameters = new Dictionary <string, object>();

            if (materialInput.ContainsKey("parameteres"))
            {
                globalParameters = (Dictionary <string, object>)materialInput["parameters"];
            }

            Dictionary <string, object> globalState = new Dictionary <string, object>();

            if (materialInput.ContainsKey("state"))
            {
                globalState = (Dictionary <string, object>)materialInput["state"];
            }

            List <ShaderSourceContent> shaderSources = new List <ShaderSourceContent>();

            int passCount = 0;

            foreach (Dictionary <string, object> item in ((List <object>)materialInput["passes"]).Cast <Dictionary <string, object> >())
            {
                MaterialContent.Pass pass = new MaterialContent.Pass();
                if (item.ContainsKey("name"))
                {
                    pass.Name = (string)item["name"];
                }

                if (!item.ContainsKey("vs"))
                {
                    throw new ContentException(string.Format("Pass {0} is missing the required key vs.", passCount));
                }
                if (!item.ContainsKey("fs"))
                {
                    throw new ContentException(string.Format("Pass {0} is missing the required key fs.", passCount));
                }

                if (item["vs"] is string)
                {
                    object content;
                    pass.VertexShaderSources.Add(
                        context.ContentManager.BuildContent <ShaderSourceContent>((string)item["vs"], out content,
                                                                                  importerData: new Dictionary <string, object>()
                    {
                        { "ShaderType", "VertexShader" }
                    }));
                    shaderSources.Add((ShaderSourceContent)content);
                }
                else if (item["vs"] is List <string> )
                {
                    pass.VertexShaderSources.AddRange(((List <string>)item["vs"]).Select(
                                                          f =>
                    {
                        object content;
                        ExternalReferenceContent <ShaderSourceContent> result = context.ContentManager.BuildContent <
                            ShaderSourceContent>(f, out content, importerData: new Dictionary <string, object>()
                        {
                            { "ShaderType", "VertexShader" }
                        });
                        shaderSources.Add((ShaderSourceContent)content);
                        return(result);
                    }));
                }
                else
                {
                    throw new ContentException(string.Format("In Pass {0} vs must be either a string or a list of strings.", passCount));
                }

                if (item["fs"] is string)
                {
                    object content;
                    pass.VertexShaderSources.Add(
                        context.ContentManager.BuildContent <ShaderSourceContent>((string)item["fs"], out content,
                                                                                  importerData: new Dictionary <string, object>()
                    {
                        { "ShaderType", "FragmentShader" }
                    }));
                    shaderSources.Add((ShaderSourceContent)content);
                }
                else if (item["fs"] is List <string> )
                {
                    pass.VertexShaderSources.AddRange(((List <string>)item["fs"]).Select(
                                                          f =>
                    {
                        object content;
                        ExternalReferenceContent <ShaderSourceContent> result = context.ContentManager.BuildContent <ShaderSourceContent>(f, out content, importerData: new Dictionary <string, object>()
                        {
                            { "ShaderType", "FragmentShader" }
                        });
                        shaderSources.Add((ShaderSourceContent)content);
                        return(result);
                    }
                                                          ));
                }
                else
                {
                    throw new ContentException(string.Format("In Pass {0} fs must be either a string or a list of strings.", passCount));
                }

                Dictionary <string, object> parameters = new Dictionary <string, object>();
                if (item.ContainsKey("parameters"))
                {
                    parameters = (Dictionary <string, object>)item["parameters"];
                }

                (new[] { globalParameters, parameters }).SelectMany(x => x).ToList().ForEach(x => pass.Parameters[x.Key] = ParseMaterialParameter(x.Value, context.ContentManager));

                Dictionary <string, object> stateData = new Dictionary <string, object>(globalState);
                if (item.ContainsKey("state"))
                {
                    ((Dictionary <string, object>)item["state"]).ToList().ForEach(x => stateData[x.Key] = x.Value);
                }


                pass.State = CreateState(stateData);

                material.Passes.Add(pass);

                passCount++;
            }

            return(material);
        }