public void T001_ToFromBinaryTest()
{
RenderMaterial mat = new RenderMaterial ();
RenderMaterials mats = new RenderMaterials ();
String key = UUID.Random().ToString();
mats.Materials.Add(key, mat);
byte[] bytes = mats.ToBytes ();
RenderMaterials newmats = RenderMaterials.FromBytes(bytes, 0);
RenderMaterial newmat = newmats.Materials[key];
Assert.That (mat, Is.EqualTo(newmat));
}
public void T000_OSDFromToTest()
{
RenderMaterial mat = new RenderMaterial ();
OSD map = mat.GetOSD ();
RenderMaterial matFromOSD = RenderMaterial.FromOSD (map);
Assert.That (mat, Is.EqualTo (matFromOSD));
Assert.That (matFromOSD.NormalID, Is.EqualTo (UUID.Zero));
Assert.That (matFromOSD.NormalOffsetX, Is.EqualTo (0.0f));
Assert.That (matFromOSD.NormalOffsetY, Is.EqualTo(0.0f));
Assert.That (matFromOSD.NormalRepeatX, Is.EqualTo(1.0f));
Assert.That (matFromOSD.NormalRepeatY, Is.EqualTo(1.0f));
Assert.That (matFromOSD.NormalRotation, Is.EqualTo(0.0f));
Assert.That (matFromOSD.SpecularOffsetX, Is.EqualTo(0.0f));
Assert.That (matFromOSD.SpecularOffsetY, Is.EqualTo(0.0f));
Assert.That (matFromOSD.SpecularRepeatX, Is.EqualTo(1.0f));
Assert.That (matFromOSD.SpecularRepeatY, Is.EqualTo(1.0f));
Assert.That (matFromOSD.SpecularRotation, Is.EqualTo(0.0f));
Assert.That (matFromOSD.SpecularLightColor, Is.EqualTo(RenderMaterial.DEFAULT_SPECULAR_LIGHT_COLOR));
Assert.That (matFromOSD.SpecularLightExponent, Is.EqualTo(RenderMaterial.DEFAULT_SPECULAR_LIGHT_EXPONENT));
Assert.That (matFromOSD.EnvironmentIntensity, Is.EqualTo(RenderMaterial.DEFAULT_ENV_INTENSITY));
Assert.That (matFromOSD.DiffuseAlphaMode, Is.EqualTo((byte)RenderMaterial.eDiffuseAlphaMode.DIFFUSE_ALPHA_MODE_BLEND));
Assert.That (matFromOSD.AlphaMaskCutoff, Is.EqualTo(0));
}
public UUID AddMaterial(RenderMaterial mat)
{
lock (Materials)
{
UUID key = RenderMaterial.GenerateMaterialID(mat);
if (Materials.ContainsKey(key.Guid) == false)
Materials[key.Guid] = mat;
return key;
}
}
public static UUID GenerateMaterialID(RenderMaterial material)
{
return (new UUID(material.ComputeMD5Hash(), 0));
}
public static RenderMaterial FromOSD (OSD osd)
{
OSDMap map = osd as OSDMap;
RenderMaterial material = new RenderMaterial ();
material.NormalID = map [MATERIALS_CAP_NORMAL_MAP_FIELD].AsUUID ();
material.NormalOffsetX = (float)map [MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.NormalOffsetY = (float)map [MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.NormalRepeatX = (float)map [MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.NormalRepeatY = (float)map [MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.NormalRotation = (float)map [MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.SpecularID = map [MATERIALS_CAP_SPECULAR_MAP_FIELD].AsUUID ();
material.SpecularOffsetX = (float)map [MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.SpecularOffsetY = (float)map [MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.SpecularRepeatX = (float)map [MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.SpecularRepeatY = (float)map [MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
material.SpecularRotation = (float)map [MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD].AsInteger() / MATERIALS_MULTIPLIER;
OSDArray specularColor = map[MATERIALS_CAP_SPECULAR_COLOR_FIELD] as OSDArray;
material.SpecularLightColorR = (byte)specularColor[0].AsInteger ();
material.SpecularLightColorG = (byte)specularColor[1].AsInteger();
material.SpecularLightColorB = (byte)specularColor[2].AsInteger();
material.SpecularLightColorA = (byte)specularColor[3].AsInteger();
material.SpecularLightExponent = (byte)map [MATERIALS_CAP_SPECULAR_EXP_FIELD].AsInteger ();
material.EnvironmentIntensity = (byte)map [MATERIALS_CAP_ENV_INTENSITY_FIELD].AsInteger ();
material.DiffuseAlphaMode = (byte)map [MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD].AsInteger ();
material.AlphaMaskCutoff = (byte)map [MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD].AsInteger ();
return material;
}
public RenderMaterialEntry(RenderMaterial mat, uint partId)
{
material = mat;
partIds = new List<uint>();
partIds.Add(partId);
}
public void TestRenderMaterialsSerialization()
{
var sop1 = Util.RandomSOP("Root", 1);
var sop2 = Util.RandomSOP("Child1", 2);
var sop3 = Util.RandomSOP("Child2", 3);
var mat1 = new RenderMaterial(UUID.Random(), UUID.Random());
var mat2 = new RenderMaterial(UUID.Random(), UUID.Random());
sop1.Shape.RenderMaterials.AddMaterial(mat1);
sop2.Shape.RenderMaterials.AddMaterial(mat2);
SceneObjectGroup group = new SceneObjectGroup(sop1);
group.AddPart(sop2);
group.AddPart(sop3);
byte[] serBytes = null;
Assert.DoesNotThrow(() =>
{
serBytes = serEngine.SceneObjectSerializer.SerializeGroupToBytes(group, SerializationFlags.None);
});
Assert.NotNull(serBytes);
SceneObjectGroup deserObj = null;
Assert.DoesNotThrow(() =>
{
deserObj = serEngine.SceneObjectSerializer.DeserializeGroupFromBytes(serBytes);
});
var newsop1 = deserObj.GetChildPart(1);
var newsop2 = deserObj.GetChildPart(2);
var newsop3 = deserObj.GetChildPart(3);
Assert.That(sop1.Shape.RenderMaterials, Is.EqualTo(newsop1.Shape.RenderMaterials));
Assert.That(sop2.Shape.RenderMaterials, Is.EqualTo(newsop2.Shape.RenderMaterials));
Assert.That(sop3.Shape.RenderMaterials, Is.EqualTo(newsop3.Shape.RenderMaterials));
}
private void OnRenderMaterialAdded(SceneObjectPart part, UUID matID, RenderMaterial material)
{
if (part == null)
return;
lock (m_knownMaterials)
{
if (m_knownMaterials.ContainsKey(matID))
{
var entry = m_knownMaterials[matID];
if (entry.partIds.Contains(part.LocalId) == false)
entry.partIds.Add(part.LocalId);
}
else
{
m_log.DebugFormat("[RenderMaterials]: Adding new RenderMaterial {0} to region cache.", matID.ToString());
m_knownMaterials[matID] = new RenderMaterialEntry(material, part.LocalId);
}
}
}
public void TestRenderMaterialsSerialization()
{
var sop1 = SceneUtil.RandomSOP("Root", 1);
var sop2 = SceneUtil.RandomSOP("Child1", 2);
var sop3 = SceneUtil.RandomSOP("Child2", 3);
var mat1 = new RenderMaterial(UUID.Random(), UUID.Random());
var mat2 = new RenderMaterial(UUID.Random(), UUID.Random());
sop1.Shape.RenderMaterials.AddMaterial(mat1);
sop2.Shape.RenderMaterials.AddMaterial(mat2);
SceneObjectGroup group = new SceneObjectGroup(sop1);
group.AddPart(sop2);
group.AddPart(sop3);
SceneObjectGroup deserGroup = null;
string grpBytes = null;
Assert.DoesNotThrow(() =>
{
grpBytes = SceneObjectSerializer.ToXml2Format(group, true);
});
Assert.NotNull(grpBytes);
Assert.DoesNotThrow(() =>
{
deserGroup = SceneObjectSerializer.FromXml2Format(grpBytes);
});
var newsop1 = deserGroup.GetChildPart(1);
var newsop2 = deserGroup.GetChildPart(2);
var newsop3 = deserGroup.GetChildPart(3);
Assert.That(sop1.Shape.RenderMaterials, Is.EqualTo(newsop1.Shape.RenderMaterials));
Assert.That(sop2.Shape.RenderMaterials, Is.EqualTo(newsop2.Shape.RenderMaterials));
Assert.That(sop3.Shape.RenderMaterials, Is.EqualTo(newsop3.Shape.RenderMaterials));
}
public static UUID GenerateMaterialID(RenderMaterial material)
{
return(new UUID(material.ComputeMD5Hash(), 0));
}
