private void SetShinyBump(LLPrimitive obj, Shininess shiny, Bumpiness bump, int side)
{
int sides = GetNumberOfSides(obj);
if (side >= 0 && side < sides)
{
// Get or create the requested face and update
Primitive.TextureEntryFace face = obj.Prim.Textures.CreateFace((uint)side);
face.Shiny = shiny;
face.Bump = bump;
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
else if (side == LSLConstants.ALL_SIDES)
{
// Change all of the faces
for (uint i = 0; i < sides; i++)
{
Primitive.TextureEntryFace face = obj.Prim.Textures.GetFace(i);
if (face != null)
{
face.Shiny = shiny;
face.Bump = bump;
}
}
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
}
public bool Equals(Material other)
{
return(Color.Equals(other.Color) &&
Ambient.Equals(other.Ambient) &&
Diffuse.Equals(other.Diffuse) &&
Specular.Equals(other.Specular) &&
Shininess.Equals(other.Shininess));
}
public override int GetHashCode()
{
int hashCode = -2043694805;
hashCode = hashCode * -1521134295 + Ambient.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <Color> .Default.GetHashCode(Color);
hashCode = hashCode * -1521134295 + Diffuse.GetHashCode();
hashCode = hashCode * -1521134295 + Shininess.GetHashCode();
hashCode = hashCode * -1521134295 + Specular.GetHashCode();
return(hashCode);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Ambient.GetHashCode();
hashCode = (hashCode * 397) ^ Color.Truncate().GetHashCode();
hashCode = (hashCode * 397) ^ Diffuse.Truncate().GetHashCode();
hashCode = (hashCode * 397) ^ Shininess.Truncate().GetHashCode();
hashCode = (hashCode * 397) ^ Specular.Truncate().GetHashCode();
return(hashCode);
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Color != null?Color.GetHashCode() : 0;
hashCode = (hashCode * 397) ^ Ambient.GetHashCode();
hashCode = (hashCode * 397) ^ Diffuse.GetHashCode();
hashCode = (hashCode * 397) ^ Specular.GetHashCode();
hashCode = (hashCode * 397) ^ Shininess.GetHashCode();
return(hashCode);
}
}
public override int GetHashCode()
{
return
(Color.GetHashCode() ^
Ambient.GetHashCode() ^
Diffuse.GetHashCode() ^
Specular.GetHashCode() ^
Shininess.GetHashCode() ^
Pattern.GetHashCode() ^
Reflective.GetHashCode() ^
Transparency.GetHashCode() ^
RefractiveIndex.GetHashCode());
}
public override bool Equals(object obj)
{
var other = obj as Material;
return((other != null) &&
(Color.Equals(other.Color)) &&
(Ambient.IsEqual(other.Ambient)) &&
(Diffuse.IsEqual(other.Diffuse)) &&
(Specular.IsEqual(other.Specular)) &&
(Shininess.IsEqual(other.Shininess)) &&
(Reflective.IsEqual(other.Reflective)) &&
(Transparency.IsEqual(other.Transparency)) &&
(RefractiveIndex.IsEqual(other.RefractiveIndex)));
}
private float ShinyToPercent(Shininess shininess)
{
switch (shininess)
{
case Shininess.High:
return(1.0f);
case Shininess.Medium:
return(0.5f);
case Shininess.Low:
return(0.25f);
}
return(0.0f);
}
public bool Equals(Material other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
(Ambient.IsEquivalentTo(other.Ambient) &&
Color.IsEquivalentTo(other.Color) &&
Diffuse.IsEquivalentTo(other.Diffuse) &&
Shininess.IsEquivalentTo(other.Shininess) &&
Specular.IsEquivalentTo(other.Specular));
}
public override void Render(StringBuilder sb)
{
if (string.IsNullOrWhiteSpace(DEF) && string.IsNullOrWhiteSpace(USE) && DiffuseColor != null)
{
DEF = "Mat" + Guid.NewGuid().ToString();
}
AddProperty("DEF", DEF);
AddProperty("USE", USE);
AddProperty("diffuseColor", Vector3.ToString(DiffuseColor));
AddProperty("emissiveColor", Vector3.ToString(EmissiveColor));
AddProperty("specularColor", Vector3.ToString(SpecularColor));
AddProperty("textureScale", Vector2.ToString(TextureScale));
AddProperty("transparency", Transparency == null ? null : Transparency.ToString());
AddProperty("ambientIntensity", AmbientIntensity == null ? null : AmbientIntensity.ToString());
AddProperty("shininess", Shininess == null ? null : Shininess.ToString());
AddProperty("occluded", Occluded.ToSlamString());
base.Render(sb);
}
public void Validate()
{
if (!Color.IsColor())
{
throw new ArgumentException("Color is not a color", nameof(Color));
}
if (!Ambient.IsInUnitRange())
{
throw new ArgumentOutOfRangeException(nameof(Ambient));
}
if (!Diffuse.IsInUnitRange())
{
throw new ArgumentOutOfRangeException(nameof(Diffuse));
}
if (!Specular.IsInUnitRange())
{
throw new ArgumentOutOfRangeException(nameof(Specular));
}
if (!Shininess.IsPositive())
{
throw new ArgumentOutOfRangeException(nameof(Shininess));
}
}
protected override void WriteDataXML(XElement ele, ElderScrollsPlugin master)
{
XElement subEle;
ele.TryPathTo("Width/Min", true, out subEle);
subEle.Value = MinWidth.ToString("G15");
ele.TryPathTo("Width/Max", true, out subEle);
subEle.Value = MaxWidth.ToString("G15");
ele.TryPathTo("Height/Min", true, out subEle);
subEle.Value = MinHeight.ToString("G15");
ele.TryPathTo("Height/Max", true, out subEle);
subEle.Value = MaxHeight.ToString("G15");
ele.TryPathTo("Depth", true, out subEle);
subEle.Value = Depth.ToString("G15");
ele.TryPathTo("Shininess", true, out subEle);
subEle.Value = Shininess.ToString("G15");
ele.TryPathTo("Parallax/Scale", true, out subEle);
subEle.Value = ParallaxScale.ToString("G15");
ele.TryPathTo("Parallax/Passes", true, out subEle);
subEle.Value = ParallaxPasses.ToString();
ele.TryPathTo("Flags", true, out subEle);
subEle.Value = DecalFlags.ToString();
WriteUnusedXML(ele, master);
ele.TryPathTo("Color", true, out subEle);
Color.WriteXML(subEle, master);
}
public void SetShiny(SceneObjectPart part, int face, int shiny, Bumpiness bump)
{
Shininess sval = new Shininess();
switch (shiny)
{
case 0:
sval = Shininess.None;
break;
case 1:
sval = Shininess.Low;
break;
case 2:
sval = Shininess.Medium;
break;
case 3:
sval = Shininess.High;
break;
default:
sval = Shininess.None;
break;
}
Primitive.TextureEntry tex = part.Shape.Textures;
if (face >= 0 && face < GetNumberOfSides(part))
{
tex.CreateFace((uint) face);
tex.FaceTextures[face].Shiny = sval;
tex.FaceTextures[face].Bump = bump;
part.UpdateTextureEntry(tex.GetBytes());
return;
}
else if (face == ScriptBaseClass.ALL_SIDES)
{
for (uint i = 0; i < GetNumberOfSides(part); i++)
{
if (tex.FaceTextures[i] != null)
{
tex.FaceTextures[i].Shiny = sval;
tex.FaceTextures[i].Bump = bump;;
}
tex.DefaultTexture.Shiny = sval;
tex.DefaultTexture.Bump = bump;
}
part.UpdateTextureEntry(tex.GetBytes());
return;
}
}
private void SetTexPrimitiveParams(TextureEntryFace face, PrimitiveParamsType type, AnArray.MarkEnumerator enumerator, ref UpdateChangedFlags flags, ref bool isUpdated, bool updateParams)
{
switch (type)
{
case PrimitiveParamsType.Texture:
{
UUID textureID = m_Part.GetTextureParam(enumerator, "PRIM_TEXTURE");
Vector3 repeats = ParamsHelper.GetVector(enumerator, "PRIM_TEXTURE");
Vector3 offsets = ParamsHelper.GetVector(enumerator, "PRIM_TEXTURE");
float rot = (float)ParamsHelper.GetDouble(enumerator, "PRIM_TEXTURE");
if (updateParams)
{
if (m_Part.TryFetchTexture(textureID))
{
face.TextureID = textureID;
}
face.RepeatU = (float)repeats.X;
face.RepeatV = (float)repeats.Y;
face.OffsetU = (float)offsets.X;
face.OffsetV = (float)offsets.Y;
face.Rotation = rot;
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.Color:
{
Vector3 color = ParamsHelper.GetVector(enumerator, "PRIM_COLOR");
double alpha = ParamsHelper.GetDouble(enumerator, "PRIM_COLOR").Clamp(0, 1);
if (updateParams)
{
face.TextureColor = new ColorAlpha(color, alpha);
flags |= UpdateChangedFlags.Color;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.Alpha:
{
double alpha = ParamsHelper.GetDouble(enumerator, "PRIM_ALPHA").Clamp(0, 1);
if (updateParams)
{
ColorAlpha color = face.TextureColor;
color.A = alpha;
face.TextureColor = color;
flags |= UpdateChangedFlags.Color;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.BumpShiny:
{
Shininess shiny = (Shininess)ParamsHelper.GetInteger(enumerator, "PRIM_BUMP_SHINY");
Bumpiness bump = (Bumpiness)ParamsHelper.GetInteger(enumerator, "PRIM_BUMP_SHINY");
if (updateParams)
{
face.Shiny = shiny;
face.Bump = bump;
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.FullBright:
{
bool fbright = ParamsHelper.GetBoolean(enumerator, "PRIM_FULLBRIGHT");
if (updateParams)
{
face.FullBright = fbright;
flags |= UpdateChangedFlags.Color;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.TexGen:
{
MappingType mapType = (MappingType)ParamsHelper.GetInteger(enumerator, "PRIM_TEXGEN");
if (updateParams)
{
face.TexMapType = mapType;
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.Glow:
{
float glow = (float)ParamsHelper.GetDouble(enumerator, "PRIM_GLOW").Clamp(0, 1);
if (updateParams)
{
face.Glow = glow;
flags |= UpdateChangedFlags.Color;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.AlphaMode:
/* [ PRIM_ALPHA_MODE, integer face, integer alpha_mode, integer mask_cutoff ] */
{
Material mat;
try
{
mat = m_Part.ObjectGroup.Scene.GetMaterial(face.MaterialID);
}
catch
{
mat = new Material();
}
mat.DiffuseAlphaMode = ParamsHelper.GetInteger(enumerator, "PRIM_ALPHA_MODE");
mat.AlphaMaskCutoff = ParamsHelper.GetInteger(enumerator, "PRIM_ALPHA_MODE");
if (updateParams)
{
mat.DiffuseAlphaMode = mat.DiffuseAlphaMode.Clamp(0, 3);
mat.AlphaMaskCutoff = mat.AlphaMaskCutoff.Clamp(0, 3);
mat.MaterialID = UUID.Random;
m_Part.ObjectGroup.Scene.StoreMaterial(mat);
face.MaterialID = mat.MaterialID;
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.Normal:
/* [ PRIM_NORMAL, integer face, string texture, vector repeats, vector offsets, float rotation_in_radians ] */
{
UUID texture = m_Part.GetTextureParam(enumerator, "PRIM_NORMAL");
Vector3 repeats = ParamsHelper.GetVector(enumerator, "PRIM_NORMAL");
Vector3 offsets = ParamsHelper.GetVector(enumerator, "PRIM_NORMAL");
double rotation = ParamsHelper.GetDouble(enumerator, "PRIM_NORMAL");
if (updateParams)
{
repeats.X *= Material.MATERIALS_MULTIPLIER;
repeats.Y *= Material.MATERIALS_MULTIPLIER;
offsets.X *= Material.MATERIALS_MULTIPLIER;
offsets.Y *= Material.MATERIALS_MULTIPLIER;
rotation %= Math.PI * 2;
rotation *= Material.MATERIALS_MULTIPLIER;
Material mat;
try
{
mat = m_Part.ObjectGroup.Scene.GetMaterial(face.MaterialID);
}
catch
{
mat = new Material();
}
mat.NormMap = texture;
mat.NormOffsetX = (int)Math.Round(offsets.X);
mat.NormOffsetY = (int)Math.Round(offsets.Y);
mat.NormRepeatX = (int)Math.Round(repeats.X);
mat.NormRepeatY = (int)Math.Round(repeats.Y);
mat.NormRotation = (int)Math.Round(rotation);
mat.MaterialID = UUID.Random;
if (m_Part.TryFetchTexture(texture))
{
m_Part.ObjectGroup.Scene.StoreMaterial(mat);
face.MaterialID = mat.MaterialID;
}
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
case PrimitiveParamsType.Specular:
/* [ PRIM_SPECULAR, integer face, string texture, vector repeats, vector offsets, float rotation_in_radians, vector color, integer glossiness, integer environment ] */
{
UUID texture = m_Part.GetTextureParam(enumerator, "PRIM_NORMAL");
Vector3 repeats = ParamsHelper.GetVector(enumerator, "PRIM_SPECULAR");
Vector3 offsets = ParamsHelper.GetVector(enumerator, "PRIM_SPECULAR");
repeats *= Material.MATERIALS_MULTIPLIER;
offsets *= Material.MATERIALS_MULTIPLIER;
double rotation = ParamsHelper.GetDouble(enumerator, "PRIM_SPECULAR");
rotation %= Math.PI * 2;
rotation *= Material.MATERIALS_MULTIPLIER;
var color = new ColorAlpha(ParamsHelper.GetVector(enumerator, "PRIM_SPECULAR"), 1);
int glossiness = ParamsHelper.GetInteger(enumerator, "PRIM_SPECULAR");
int environment = ParamsHelper.GetInteger(enumerator, "PRIM_SPECULAR");
if (updateParams)
{
environment = environment.Clamp(0, 255);
glossiness = glossiness.Clamp(0, 255);
Material mat;
try
{
mat = m_Part.ObjectGroup.Scene.GetMaterial(face.MaterialID);
}
catch
{
mat = new Material();
}
mat.SpecColor = color;
mat.SpecMap = texture;
mat.SpecOffsetX = (int)Math.Round(offsets.X);
mat.SpecOffsetY = (int)Math.Round(offsets.Y);
mat.SpecRepeatX = (int)Math.Round(repeats.X);
mat.SpecRepeatY = (int)Math.Round(repeats.Y);
mat.SpecRotation = (int)Math.Round(rotation);
mat.EnvIntensity = environment;
mat.SpecExp = glossiness;
mat.MaterialID = UUID.Random;
if (m_Part.TryFetchTexture(texture))
{
m_Part.ObjectGroup.Scene.StoreMaterial(mat);
face.MaterialID = mat.MaterialID;
}
flags |= UpdateChangedFlags.Texture;
isUpdated = true;
}
}
break;
default:
throw new ArgumentException($"Internal error! Primitive parameter type {type} should not be passed to PrimitiveFace");
}
}
private void SetShinyBump(LLPrimitive obj, Shininess shiny, Bumpiness bump, int side)
{
int sides = GetNumberOfSides(obj);
if (side >= 0 && side < sides)
{
// Get or create the requested face and update
Primitive.TextureEntryFace face = obj.Prim.Textures.CreateFace((uint)side);
face.Shiny = shiny;
face.Bump = bump;
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
else if (side == LSLConstants.ALL_SIDES)
{
// Change all of the faces
for (uint i = 0; i < sides; i++)
{
Primitive.TextureEntryFace face = obj.Prim.Textures.GetFace(i);
if (face != null)
{
face.Shiny = shiny;
face.Bump = bump;
}
}
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
}
private void SetPrimParams(IScriptInstance script, ISceneEntity entity, object[] rules)
{
LLPrimitive prim = entity as LLPrimitive;
if (prim == null)
{
return;
}
bool changedShape = false, changedColor = false, changedTexture = false;
int i = 0;
while (i < rules.Length)
{
int code = llList2Integer(script, rules, i++);
switch (code)
{
case LSLConstants.PRIM_NAME:
{
SetObjectName(prim, llList2String(script, rules, i++));
break;
}
case LSLConstants.PRIM_DESC:
{
SetObjectDesc(prim, llList2String(script, rules, i++));
break;
}
case LSLConstants.PRIM_TYPE:
{
SetPrimType(script, rules, ref i);
prim.Scene.EntityAddOrUpdate(this, prim, UpdateFlags.Shape, 0);
changedShape = true;
break;
}
case LSLConstants.PRIM_MATERIAL:
{
prim.Prim.PrimData.Material = (Material)llList2Integer(script, rules, i++);
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.Material);
break;
}
case LSLConstants.PRIM_PHYSICS:
{
SetStatus(prim, LSLConstants.STATUS_PHYSICS, llList2Integer(script, rules, i++));
break;
}
case LSLConstants.PRIM_TEMP_ON_REZ:
{
bool tempOnRez = (llList2Integer(script, rules, i++) != 0);
LLPrimitive parent = GetRootEntity(prim) as LLPrimitive;
if (parent != null)
{
if (tempOnRez)
{
parent.Prim.Flags |= PrimFlags.TemporaryOnRez;
}
else
{
parent.Prim.Flags &= ~PrimFlags.TemporaryOnRez;
}
parent.Scene.EntityAddOrUpdate(this, parent, 0, (uint)LLUpdateFlags.PrimFlags);
}
break;
}
case LSLConstants.PRIM_PHANTOM:
{
SetStatus(prim, LSLConstants.STATUS_PHANTOM, llList2Integer(script, rules, i++));
break;
}
case LSLConstants.PRIM_POSITION:
{
SetPos(prim, llList2Vector(script, rules, i++));
break;
}
case LSLConstants.PRIM_ROTATION:
{
SetRot(prim, llList2Rot(script, rules, i++));
break;
}
case LSLConstants.PRIM_SIZE:
{
SetScale(prim, llList2Vector(script, rules, i++));
break;
}
case LSLConstants.PRIM_TEXTURE:
{
int face = llList2Integer(script, rules, i++);
string texture = llList2String(script, rules, i++);
Vector3 repeats = llList2Vector(script, rules, i++);
Vector3 offsets = llList2Vector(script, rules, i++);
float rotRadians = llList2Float(script, rules, i++);
SetTexture(script, prim, texture, face);
ScaleTexture(script, prim, repeats.X, repeats.Y, face);
OffsetTexture(script, prim, offsets.X, offsets.Y, face);
RotateTexture(script, prim, rotRadians, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_TEXT:
{
string text = llList2String(script, rules, i++);
Vector3 color = llList2Vector(script, rules, i++);
float alpha = llList2Float(script, rules, i++);
SetText(prim, text, color, alpha);
break;
}
case LSLConstants.PRIM_COLOR:
{
int face = llList2Integer(script, rules, i++);
Vector3 color = llList2Vector(script, rules, i++);
float alpha = llList2Float(script, rules, i++);
SetColor(prim, color, face);
SetAlpha(prim, alpha, face);
changedColor = true;
break;
}
case LSLConstants.PRIM_BUMP_SHINY:
{
int face = llList2Integer(script, rules, i++);
Shininess shiny = (Shininess)llList2Integer(script, rules, i++);
Bumpiness bump = (Bumpiness)llList2Integer(script, rules, i++);
SetShinyBump(prim, shiny, bump, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_POINT_LIGHT:
{
bool enabled = (llList2Integer(script, rules, i++) != 0);
Vector3 color = llList2Vector(script, rules, i++);
float intensity = llList2Float(script, rules, i++);
float radius = llList2Float(script, rules, i++);
float falloff = llList2Float(script, rules, i++);
if (enabled)
{
Primitive.LightData light = new Primitive.LightData();
light.Color = new Color4(
Utils.Clamp(color.X, 0f, 1f),
Utils.Clamp(color.Y, 0f, 1f),
Utils.Clamp(color.Z, 0f, 1f),
1f);
light.Intensity = intensity;
light.Radius = radius;
light.Falloff = falloff;
prim.Prim.Light = light;
}
else
{
prim.Prim.Light = null;
}
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.ExtraData);
break;
}
case LSLConstants.PRIM_FULLBRIGHT:
{
int face = llList2Integer(script, rules, i++);
bool fullbright = (llList2Integer(script, rules, i++) != 0);
SetFullbright(prim, fullbright, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_FLEXIBLE:
{
bool enabled = (llList2Integer(script, rules, i++) != 0);
int softness = llList2Integer(script, rules, i++);
float gravity = llList2Float(script, rules, i++);
float friction = llList2Float(script, rules, i++);
float wind = llList2Float(script, rules, i++);
float tension = llList2Float(script, rules, i++);
Vector3 force = llList2Vector(script, rules, i++);
if (enabled)
{
Primitive.FlexibleData flex = new Primitive.FlexibleData();
flex.Softness = softness;
flex.Gravity = gravity;
flex.Drag = friction;
flex.Wind = wind;
flex.Tension = tension;
flex.Force = force;
prim.Prim.Flexible = flex;
}
else
{
prim.Prim.Flexible = null;
}
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.ExtraData);
break;
}
case LSLConstants.PRIM_TEXGEN:
{
int face = llList2Integer(script, rules, i++);
MappingType texgen = (MappingType)llList2Integer(script, rules, i++);
SetTexgen(prim, texgen, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_GLOW:
{
int face = llList2Integer(script, rules, i++);
float intensity = llList2Float(script, rules, i++);
SetGlow(prim, intensity, face);
changedTexture = true;
break;
}
}
}
if (m_lslScriptEngine != null)
{
if (changedShape)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_SHAPE }, null);
}
if (changedTexture)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_TEXTURE }, null);
}
if (changedColor)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_COLOR }, null);
}
}
}
private void SetShiny(SceneObjectPart part, int shiny, Bumpiness bump, int face)
{
Shininess sval = new Shininess();
switch (shiny)
{
case 0:
sval = Shininess.None;
break;
case 1:
sval = Shininess.Low;
break;
case 2:
sval = Shininess.Medium;
break;
case 3:
sval = Shininess.High;
break;
default:
sval = Shininess.None;
break;
}
Primitive.TextureEntry tex = part.Shape.Textures;
if (face >= 0 && face < MAX_SIDES)
{
tex.CreateFace((uint)face);
tex.FaceTextures[face].Shiny = sval;
tex.FaceTextures[face].Bump = bump;
part.UpdateTexture(tex);
return;
}
else if (face == ALL_SIDES)
{
for (uint i = 0; i < MAX_SIDES; i++)
{
if (tex.FaceTextures[i] != null)
{
tex.FaceTextures[i].Shiny = sval;
tex.FaceTextures[i].Bump = bump; ;
}
tex.DefaultTexture.Shiny = sval;
tex.DefaultTexture.Bump = bump;
}
part.UpdateTexture(tex);
return;
}
}
private bool Equals(Material other)
{
return(Equals(Color, other.Color) && Ambient.AlmostEqual(other.Ambient) &&
Diffuse.AlmostEqual(other.Diffuse) &&
Specular.AlmostEqual(other.Specular) && Shininess.AlmostEqual(other.Shininess));
}
