public override void Write(ContentWriter writer, UniformValueContent value)
{
writer.Write((int)value.ValueType);
if (value.ValueType == UniformValueType.Int)
{
writer.WriteRawObject(value.Values.Cast <int>().ToArray());
}
else if (value.ValueType == UniformValueType.UInt)
{
writer.WriteRawObject(value.Values.Cast <uint>().ToArray());
}
else if (value.ValueType == UniformValueType.Float)
{
writer.WriteRawObject(value.Values.Cast <float>().ToArray());
}
else if (value.ValueType == UniformValueType.Matrix)
{
writer.WriteRawObject((OpenTK.Matrix4)value.Values[0]);
}
else if (value.ValueType == UniformValueType.Texture)
{
writer.WriteRawObject((TextureContent)value.Values[0]);
writer.Write((byte)value.Values[1]);
}
else if (value.ValueType == UniformValueType.Sampler)
{
SamplerContent sampler = (SamplerContent)value.Values[0];
writer.WriteRawObject(sampler.Texture);
writer.Write(sampler.Slot);
writer.WriteRawObject(sampler.GetParameters());
}
}
public static UniformDefinition Create(string name, SamplerContent sampler, List <string> aliases = null)
{
if (aliases == null)
{
aliases = new List <string>();
}
return(new UniformDefinition(name, ActiveUniformType.Sampler2D, aliases,
new UniformValueContent(Minotaur.Graphics.UniformValueType.Sampler, new object[] { sampler })));
}
public static UniformDefinition Create(string name, string path, List <string> aliases = null)
{
if (aliases == null)
{
aliases = new List <string>();
}
SamplerContent sampler = new SamplerContent()
{
Texture = new ExternalReferenceContent <TextureContent>(path)
};
return(new UniformDefinition(name, ActiveUniformType.Sampler2D, aliases,
new UniformValueContent(Minotaur.Graphics.UniformValueType.Sampler, new object[] { sampler })));
}
public UniformValueContent ParseMaterialParameter(object parameter, ContentManager manager)
{
if (parameter is long)
{
return(new UniformValueContent(UniformValueType.Int, new object[] { (int)parameter }));
}
else if (parameter is double)
{
return(new UniformValueContent(UniformValueType.Float, new object[] { (float)parameter }));
}
else if (parameter is string)
{
string p = (string)parameter;
if (p.StartsWith("int(") && p.EndsWith(")"))
{
string[] args = p.Remove(0, 4).TrimEnd(new[] { ')' }).Split(',');
if (args.Length > 0 && args.Length <= 4 && args.All(s => s.IsInt()))
{
return(new UniformValueContent(UniformValueType.Int, args.Select(s => int.Parse(s)).Cast <object>().ToArray()));
}
else
{
throw new ContentException("Material parameter int() must contain 1-4 integers");
}
}
if (p.StartsWith("float(") && p.EndsWith(")"))
{
string[] args = p.Remove(0, 6).TrimEnd(new[] { ')' }).Split(',');
if (args.Length > 0 && args.Length <= 4 && args.All(s => s.IsFloat()))
{
return(new UniformValueContent(UniformValueType.Float, args.Select(s => float.Parse(s)).Cast <object>().ToArray()));
}
else
{
throw new ContentException("Material parameter float() must contain 1-4 floats");
}
}
if (p.StartsWith("uint(") && p.EndsWith(")"))
{
string[] args = p.Remove(0, 5).TrimEnd(new[] { ')' }).Split(',');
if (args.Length > 0 && args.Length <= 4 && args.All(s => s.IsUInt()))
{
return(new UniformValueContent(UniformValueType.UInt, args.Select(s => uint.Parse(s)).Cast <object>().ToArray()));
}
else
{
throw new ContentException("Material parameter uint() must contain 1-4 unsigned integers");
}
}
if (p.StartsWith("matrix(") && p.EndsWith(")"))
{
string[] args = p.Remove(0, 7).TrimEnd(new[] { ')' }).Split(',');
if (args.Length == 16 && args.All(s => s.IsFloat()))
{
float[] m = args.Select(s => float.Parse(s)).ToArray();
return(new UniformValueContent(UniformValueType.Matrix,
new object[] { new Matrix4(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]) }));
}
else
{
throw new ContentException("Material parameter matrix() must contain 16 floats");
}
}
// if previous not matched it is a texture reference so create a default sampler and add the texture.
SamplerContent content = new SamplerContent();
content.Texture = new ExternalReferenceContent <TextureContent>(manager.ProcessorContext.GetFilenamePath(p), manager)
{
ImporterData = new Dictionary <string, object>()
{
{ "GenerateMipmaps", GenerateMipmaps }, { "PremultiplyAlpha", PremultiplyAlpha }, { "OutputType", OutputType }
}
};
return(new UniformValueContent(UniformValueType.Sampler, new object[] { content }));
}
else if (parameter is Dictionary <string, object> )
{
Dictionary <string, object> p = (Dictionary <string, object>)parameter;
SamplerContent content = new SamplerContent();
if (!p.ContainsKey("texture"))
{
throw new ContentException("Sampler is missing the required texture parameter");
}
content.Texture = new ExternalReferenceContent <TextureContent>(manager.ProcessorContext.GetFilenamePath((string)p["texture"]), manager)
{
ImporterData = new Dictionary <string, object>()
{
{ "GenerateMipmaps", GenerateMipmaps }, { "PremultiplyAlpha", PremultiplyAlpha }, { "OutputType", OutputType }
}
};
object value;
if (p.TryGetValue("minfilter", out value))
{
content.MinFilter = ParseEnum <TextureMinFilter>((string)value, "minfilter");
}
if (p.TryGetValue("magfilter", out value))
{
content.MagFilter = ParseEnum <TextureMagFilter>((string)value, "magfilter");
}
if (p.TryGetValue("lodmin", out value))
{
float f;
if (!float.TryParse((string)value, out f))
{
throw new ContentException("Parameter lodmin must be a float.");
}
content.LodMin = f;
}
if (p.TryGetValue("lodmax", out value))
{
float f;
if (!float.TryParse((string)value, out f))
{
throw new ContentException("Parameter lodmax must be a float.");
}
content.LodMax = f;
}
if (p.TryGetValue("lodbias", out value))
{
float f;
if (!float.TryParse((string)value, out f))
{
throw new ContentException("Parameter lodbias must be a float.");
}
content.LodBias = f;
}
if (p.TryGetValue("wraps", out value))
{
content.WrapS = ParseEnum <TextureWrapMode>((string)value, "wraps");
}
if (p.TryGetValue("wrapt", out value))
{
content.WrapT = ParseEnum <TextureWrapMode>((string)value, "wrapt");
}
if (p.TryGetValue("wrapr", out value))
{
content.WrapR = ParseEnum <TextureWrapMode>((string)value, "wrapr");
}
if (p.TryGetValue("slot", out value))
{
int i;
if (!int.TryParse((string)value, out i))
{
throw new ContentException("Parameter slot must be an integer.");
}
content.LodMax = i;
}
return(new UniformValueContent(UniformValueType.Sampler, new object[] { content }));
}
throw new ContentException(string.Format("Unknown Material parameter {0}", parameter));
}
private void GetMaterialParameters(Material material, Dictionary <string, object> parameters, ContentProcessorContext context)
{
foreach (Assimp.TextureType type in (Assimp.TextureType[])Enum.GetValues(typeof(Assimp.TextureType)))
{
if (type == Assimp.TextureType.None || type == Assimp.TextureType.Unknown || material.GetTextureCount(type) == 0)
{
continue;
}
TextureSlot tex = material.GetTexture(type, 0); // we dont handle multiple textures of a given type so just get the first one.
string parameterName = "";
if (tex.TextureType == Assimp.TextureType.Normals)
{
parameterName = "NormalMap";
}
else
{
parameterName = string.Format("{0}Map", tex.TextureType.ToString());
}
SamplerContent sampler = new SamplerContent();
string path = File.Exists(tex.FilePath) ? tex.FilePath : Path.GetFileName(tex.FilePath);
sampler.Texture = new ExternalReferenceContent <TextureContent>(context.ContentManager.ProcessorContext.GetFilenamePath(path), context.ContentManager)
{
ImporterData = new Dictionary <string, object>()
{
{ "GenerateMipmaps", GenerateMipmaps }, { "PremultiplyAlpha", PremultiplyAlpha }, { "OutputType", OutputType }
}
};
sampler.WrapS = ConvertWrapMode(tex.WrapModeU);
sampler.WrapT = ConvertWrapMode(tex.WrapModeV);
parameters[parameterName] = new UniformValueContent(Minotaur.Graphics.UniformValueType.Sampler, new[] { sampler });
}
if (material.HasBlendMode)
{
parameters["BlendMode"] = material.BlendMode;
}
if (material.HasBumpScaling)
{
parameters["BumpScaling"] = material.BumpScaling;
}
if (material.HasColorAmbient)
{
parameters["AmbientColor"] = ConvertColor(material.ColorAmbient);
}
if (material.HasColorDiffuse)
{
parameters["DiffuseColor"] = ConvertColor(material.ColorDiffuse);
}
if (material.HasColorEmissive)
{
parameters["EmissiveColor"] = ConvertColor(material.ColorEmissive);
}
if (material.HasColorReflective)
{
parameters["ReflectiveColor"] = ConvertColor(material.ColorReflective);
}
if (material.HasColorSpecular)
{
parameters["SpecularColor"] = ConvertColor(material.ColorSpecular);
}
if (material.HasColorTransparent)
{
parameters["TransparentColor"] = ConvertColor(material.ColorTransparent);
}
if (material.HasOpacity)
{
parameters["Opacity"] = material.Opacity;
}
if (material.HasReflectivity)
{
parameters["Reflectivity"] = material.Reflectivity;
}
if (material.HasShadingMode)
{
parameters["ShadingMode"] = material.ShadingMode;
}
if (material.HasShininess)
{
parameters["Shininess"] = material.Shininess;
}
if (material.HasShininessStrength)
{
parameters["ShininessStrength"] = material.ShininessStrength;
}
if (material.HasTwoSided)
{
parameters["TwoSided"] = material.IsTwoSided;
}
if (material.HasWireFrame)
{
parameters["WireFrame"] = material.IsWireFrameEnabled;
}
}
public PassTemplate AddConstant(string name, SamplerContent sampler)
{
Constants.Add(UniformDefinition.Create(name, sampler));
return(this);
}
public PassTemplate AddVariable(string name, SamplerContent sampler, List <string> aliases = null)
{
Variables.Add(UniformDefinition.Create(name, sampler, aliases));
return(this);
}
