8806e9174c
git-svn-id: http://libopenmetaverse.googlecode.com/svn/trunk@938 52acb1d6-8a22-11de-b505-999d5b087335
982 lines
36 KiB
C#
982 lines
36 KiB
C#
/*
|
|
* Copyright (c) 2006, Second Life Reverse Engineering Team
|
|
* All rights reserved.
|
|
*
|
|
* - Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* - Neither the name of the Second Life Reverse Engineering Team nor the names
|
|
* of its contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using System.ComponentModel;
|
|
using System.IO;
|
|
|
|
namespace libsecondlife
|
|
{
|
|
public abstract partial class LLObject
|
|
{
|
|
#region Enumerations
|
|
|
|
/// <summary>
|
|
/// The type of bump-mapping applied to a face
|
|
/// </summary>
|
|
public enum Bumpiness
|
|
{
|
|
/// <summary></summary>
|
|
[XmlEnum("None")]
|
|
None = 0,
|
|
/// <summary></summary>
|
|
[XmlEnum("Brightness")]
|
|
Brightness = 1,
|
|
/// <summary></summary>
|
|
[XmlEnum("Darkness")]
|
|
Darkness = 2,
|
|
/// <summary></summary>
|
|
[XmlEnum("Woodgrain")]
|
|
Woodgrain = 3,
|
|
/// <summary></summary>
|
|
[XmlEnum("Bark")]
|
|
Bark = 4,
|
|
/// <summary></summary>
|
|
[XmlEnum("Bricks")]
|
|
Bricks = 5,
|
|
/// <summary></summary>
|
|
[XmlEnum("Checker")]
|
|
Checker = 6,
|
|
/// <summary></summary>
|
|
[XmlEnum("Concrete")]
|
|
Concrete = 7,
|
|
/// <summary></summary>
|
|
[XmlEnum("Crustytile")]
|
|
Crustytile = 8,
|
|
/// <summary></summary>
|
|
[XmlEnum("Cutstone")]
|
|
Cutstone = 9,
|
|
/// <summary></summary>
|
|
[XmlEnum("Discs")]
|
|
Discs = 10,
|
|
/// <summary></summary>
|
|
[XmlEnum("Gravel")]
|
|
Gravel = 11,
|
|
/// <summary></summary>
|
|
[XmlEnum("Petridish")]
|
|
Petridish = 12,
|
|
/// <summary></summary>
|
|
[XmlEnum("Siding")]
|
|
Siding = 13,
|
|
/// <summary></summary>
|
|
[XmlEnum("Stonetile")]
|
|
Stonetile = 14,
|
|
/// <summary></summary>
|
|
[XmlEnum("Stucco")]
|
|
Stucco = 15,
|
|
/// <summary></summary>
|
|
[XmlEnum("Suction")]
|
|
Suction = 16,
|
|
/// <summary></summary>
|
|
[XmlEnum("Weave")]
|
|
Weave = 17
|
|
}
|
|
|
|
/// <summary>
|
|
/// The level of shininess applied to a face
|
|
/// </summary>
|
|
public enum Shininess
|
|
{
|
|
/// <summary></summary>
|
|
[XmlEnum("None")]
|
|
None = 0,
|
|
/// <summary></summary>
|
|
[XmlEnum("Low")]
|
|
Low = 0x40,
|
|
/// <summary></summary>
|
|
[XmlEnum("Medium")]
|
|
Medium = 0x80,
|
|
/// <summary></summary>
|
|
[XmlEnum("High")]
|
|
High = 0xC0
|
|
}
|
|
|
|
/// <summary>
|
|
/// The texture mapping style used for a face
|
|
/// </summary>
|
|
public enum Mapping
|
|
{
|
|
/// <summary></summary>
|
|
[XmlEnum("Default")]
|
|
Default = 0,
|
|
/// <summary></summary>
|
|
[XmlEnum("Planar")]
|
|
Planar = 2
|
|
}
|
|
|
|
/// <summary>
|
|
/// Flags in the TextureEntry block that describe which properties are
|
|
/// set
|
|
/// </summary>
|
|
[Flags]
|
|
public enum TextureAttributes : uint
|
|
{
|
|
/// <summary></summary>
|
|
None = 0,
|
|
/// <summary></summary>
|
|
TextureID = 1 << 0,
|
|
/// <summary></summary>
|
|
RGBA = 1 << 1,
|
|
/// <summary></summary>
|
|
RepeatU = 1 << 2,
|
|
/// <summary></summary>
|
|
RepeatV = 1 << 3,
|
|
/// <summary></summary>
|
|
OffsetU = 1 << 4,
|
|
/// <summary></summary>
|
|
OffsetV = 1 << 5,
|
|
/// <summary></summary>
|
|
Rotation = 1 << 6,
|
|
/// <summary></summary>
|
|
Flags1 = 1 << 7,
|
|
/// <summary></summary>
|
|
Flags2 = 1 << 8,
|
|
/// <summary></summary>
|
|
All = 0xFFFFFFFF
|
|
}
|
|
|
|
#endregion Enumerations
|
|
|
|
|
|
/// <summary>
|
|
/// Represents all of the texturable faces for an object
|
|
/// </summary>
|
|
/// <remarks>Objects in Second Life have infinite faces, with each face
|
|
/// using the properties of the default face unless set otherwise. So if
|
|
/// you have a TextureEntry with a default texture uuid of X, and face 72
|
|
/// has a texture UUID of Y, every face would be textured with X except for
|
|
/// face 72 that uses Y. In practice however, primitives utilize a maximum
|
|
/// of nine faces and avatars utilize</remarks>
|
|
[Serializable]
|
|
public class TextureEntry
|
|
{
|
|
/// <summary></summary>
|
|
[XmlElement("default")]
|
|
public TextureEntryFace DefaultTexture = null;
|
|
/// <summary></summary>
|
|
[XmlElement("faces")]
|
|
public SerializableDictionary<uint, TextureEntryFace> FaceTextures = new SerializableDictionary<uint, TextureEntryFace>();
|
|
|
|
/// <summary>
|
|
/// Default constructor, DefaultTexture will remain null
|
|
/// </summary>
|
|
public TextureEntry()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor that takes a default texture UUID
|
|
/// </summary>
|
|
/// <param name="defaultTextureID">Texture UUID to use as the default texture</param>
|
|
public TextureEntry(LLUUID defaultTextureID)
|
|
{
|
|
DefaultTexture = new TextureEntryFace(null);
|
|
DefaultTexture.TextureID = defaultTextureID;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor that creates the TextureEntry class from a byte array
|
|
/// </summary>
|
|
/// <param name="data">Byte array containing the TextureEntry field</param>
|
|
/// <param name="pos">Starting position of the TextureEntry field in
|
|
/// the byte array</param>
|
|
/// <param name="length">Length of the TextureEntry field, in bytes</param>
|
|
public TextureEntry(byte[] data, int pos, int length)
|
|
{
|
|
FromBytes(data, pos, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the TextureEntryFace that is applied to the specified
|
|
/// index. If a custom texture is not set for this face that would be
|
|
/// the default texture for this TextureEntry. Do not modify the
|
|
/// returned TextureEntryFace, it will have undefined results. Use
|
|
/// CreateFace() to get a TextureEntryFace that is safe for writing
|
|
/// </summary>
|
|
/// <param name="index">The index number of the face to retrieve</param>
|
|
/// <returns>A TextureEntryFace containing all the properties for that
|
|
/// face, suitable for read-only operations</returns>
|
|
public TextureEntryFace GetFace(uint index)
|
|
{
|
|
if (FaceTextures.ContainsKey(index))
|
|
return FaceTextures[index];
|
|
else
|
|
return DefaultTexture;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check whether a custom face is defined for a particular index
|
|
/// </summary>
|
|
/// <param name="index">The index to check whether a custom face is
|
|
/// defined for</param>
|
|
/// <returns>True if this face has it's own TextureEntryFace, otherwise
|
|
/// false</returns>
|
|
public bool FaceExists(uint index)
|
|
{
|
|
return FaceTextures.ContainsKey(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This will either create a new face if a custom face for the given
|
|
/// index is not defined, or return the custom face for that index if
|
|
/// it already exists
|
|
/// </summary>
|
|
/// <param name="index">The index number of the face to create or
|
|
/// retrieve</param>
|
|
/// <returns>A TextureEntryFace containing all the properties for that
|
|
/// face</returns>
|
|
public TextureEntryFace CreateFace(uint index)
|
|
{
|
|
if (!FaceTextures.ContainsKey(index))
|
|
FaceTextures[index] = new TextureEntryFace(this.DefaultTexture);
|
|
|
|
return FaceTextures[index];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public byte[] ToBytes()
|
|
{
|
|
if (DefaultTexture == null)
|
|
{
|
|
return new byte[0];
|
|
}
|
|
|
|
MemoryStream memStream = new MemoryStream();
|
|
BinaryWriter binWriter = new BinaryWriter(memStream);
|
|
|
|
Dictionary<LLUUID, uint> TextureIDs = new Dictionary<LLUUID, uint>();
|
|
Dictionary<uint, uint> RGBAs = new Dictionary<uint, uint>();
|
|
Dictionary<short, uint> RepeatUs = new Dictionary<short, uint>();
|
|
Dictionary<short, uint> RepeatVs = new Dictionary<short, uint>();
|
|
Dictionary<short, uint> OffsetUs = new Dictionary<short, uint>();
|
|
Dictionary<short, uint> OffsetVs = new Dictionary<short, uint>();
|
|
Dictionary<short, uint> Rotations = new Dictionary<short, uint>();
|
|
Dictionary<byte, uint> Flag1s = new Dictionary<byte, uint>();
|
|
Dictionary<byte, uint> Flag2s = new Dictionary<byte, uint>();
|
|
foreach (KeyValuePair<uint, TextureEntryFace> face in FaceTextures)
|
|
{
|
|
if (face.Value.TextureID != DefaultTexture.TextureID)
|
|
{
|
|
if (TextureIDs.ContainsKey(face.Value.TextureID))
|
|
TextureIDs[face.Value.TextureID] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
TextureIDs[face.Value.TextureID] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
if (face.Value.RGBA != DefaultTexture.RGBA)
|
|
{
|
|
if (RGBAs.ContainsKey(face.Value.RGBA))
|
|
RGBAs[face.Value.RGBA] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
RGBAs[face.Value.RGBA] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
short value;
|
|
short defaultValue;
|
|
|
|
value = RepeatShort(face.Value.RepeatU);
|
|
defaultValue = RepeatShort(DefaultTexture.RepeatU);
|
|
if (value != defaultValue)
|
|
{
|
|
if (RepeatUs.ContainsKey(value))
|
|
RepeatUs[value] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
RepeatUs[value] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
value = RepeatShort(face.Value.RepeatV);
|
|
defaultValue = RepeatShort(DefaultTexture.RepeatV);
|
|
if (value != defaultValue)
|
|
{
|
|
if (RepeatVs.ContainsKey(value))
|
|
RepeatVs[value] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
RepeatVs[value] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
value = OffsetShort(face.Value.OffsetU);
|
|
defaultValue = OffsetShort(DefaultTexture.OffsetU);
|
|
if (value != defaultValue)
|
|
{
|
|
if (OffsetUs.ContainsKey(value))
|
|
OffsetUs[value] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
OffsetUs[value] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
value = OffsetShort(face.Value.OffsetV);
|
|
defaultValue = OffsetShort(DefaultTexture.OffsetV);
|
|
if (value != defaultValue)
|
|
{
|
|
if (OffsetVs.ContainsKey(value))
|
|
OffsetVs[value] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
OffsetVs[value] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
value = RotationShort(face.Value.Rotation);
|
|
defaultValue = RotationShort(DefaultTexture.Rotation);
|
|
if (value != defaultValue)
|
|
{
|
|
if (Rotations.ContainsKey(value))
|
|
Rotations[value] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
Rotations[value] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
if (face.Value.Flags1 != DefaultTexture.Flags1)
|
|
{
|
|
if (Flag1s.ContainsKey(face.Value.Flags1))
|
|
Flag1s[face.Value.Flags1] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
Flag1s[face.Value.Flags1] = (uint)(1 << (int)face.Key);
|
|
}
|
|
|
|
if (face.Value.Flags2 != DefaultTexture.Flags2)
|
|
{
|
|
if (Flag2s.ContainsKey(face.Value.Flags2))
|
|
Flag2s[face.Value.Flags2] |= (uint)(1 << (int)face.Key);
|
|
else
|
|
Flag2s[face.Value.Flags2] = (uint)(1 << (int)face.Key);
|
|
}
|
|
}
|
|
|
|
if (DefaultTexture.TextureID != null)
|
|
binWriter.Write(DefaultTexture.TextureID.Data);
|
|
else
|
|
binWriter.Write(LLUUID.Zero.Data);
|
|
foreach (KeyValuePair<LLUUID, uint> kv in TextureIDs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key.Data);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(DefaultTexture.RGBA);
|
|
foreach (KeyValuePair<uint, uint> kv in RGBAs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(RepeatShort(DefaultTexture.RepeatU));
|
|
foreach (KeyValuePair<short, uint> kv in RepeatUs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(RepeatShort(DefaultTexture.RepeatV));
|
|
foreach (KeyValuePair<short, uint> kv in RepeatVs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(OffsetShort(DefaultTexture.OffsetU));
|
|
foreach (KeyValuePair<short, uint> kv in OffsetUs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(OffsetShort(DefaultTexture.OffsetV));
|
|
foreach (KeyValuePair<short, uint> kv in OffsetVs)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(RotationShort(DefaultTexture.Rotation));
|
|
foreach (KeyValuePair<short, uint> kv in Rotations)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(DefaultTexture.Flags1);
|
|
foreach (KeyValuePair<byte, uint> kv in Flag1s)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
binWriter.Write((byte)0);
|
|
binWriter.Write(DefaultTexture.Flags2);
|
|
foreach (KeyValuePair<byte, uint> kv in Flag2s)
|
|
{
|
|
binWriter.Write(GetFaceBitfieldBytes(kv.Value));
|
|
binWriter.Write(kv.Key);
|
|
}
|
|
|
|
return memStream.ToArray();
|
|
}
|
|
|
|
private byte[] GetFaceBitfieldBytes(uint bitfield)
|
|
{
|
|
int byteLength = 0;
|
|
uint tmpBitfield = bitfield;
|
|
while (tmpBitfield != 0)
|
|
{
|
|
tmpBitfield >>= 7;
|
|
byteLength++;
|
|
}
|
|
|
|
if (byteLength == 0)
|
|
return new byte[1] { 0 };
|
|
|
|
byte[] bytes = new byte[byteLength];
|
|
for (int i = 0; i < byteLength; i++)
|
|
{
|
|
bytes[i] = (byte)((bitfield >> (7 * (byteLength - i - 1))) & 0x7F);
|
|
if (i < byteLength - 1)
|
|
bytes[i] |= 0x80;
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
private bool ReadFaceBitfield(byte[] data, ref int pos, ref uint faceBits, ref uint bitfieldSize)
|
|
{
|
|
faceBits = 0;
|
|
bitfieldSize = 0;
|
|
|
|
if (pos >= data.Length)
|
|
return false;
|
|
|
|
byte b = 0;
|
|
do
|
|
{
|
|
b = data[pos];
|
|
faceBits = (faceBits << 7) | (uint)(b & 0x7F);
|
|
bitfieldSize += 7;
|
|
pos++;
|
|
}
|
|
while ((b & 0x80) != 0);
|
|
|
|
return (faceBits != 0);
|
|
}
|
|
|
|
private float DequantizeSigned(byte[] byteArray, int pos, float upper)
|
|
{
|
|
short value = (short)(byteArray[pos] | (byteArray[pos + 1] << 8));
|
|
float QV = (float)value;
|
|
float QF = upper / 32767.0f;
|
|
return (float)(QV * QF);
|
|
}
|
|
|
|
private short QuantizeSigned(float f, float upper)
|
|
{
|
|
float QF = 32767.0F / upper;
|
|
return (short)(f * QF);
|
|
}
|
|
|
|
private short RepeatShort(float value)
|
|
{
|
|
return QuantizeSigned(value - 1.0f, 101.0f);
|
|
}
|
|
|
|
private short OffsetShort(float value)
|
|
{
|
|
return QuantizeSigned(value, 1.0f);
|
|
}
|
|
|
|
private short RotationShort(float value)
|
|
{
|
|
return QuantizeSigned(value, 359.995f);
|
|
}
|
|
|
|
private float RepeatFloat(byte[] data, int pos)
|
|
{
|
|
return DequantizeSigned(data, pos, 101.0f) + 1.0f;
|
|
}
|
|
|
|
private float OffsetFloat(byte[] data, int pos)
|
|
{
|
|
return DequantizeSigned(data, pos, 1.0f);
|
|
}
|
|
|
|
private float RotationFloat(byte[] data, int pos)
|
|
{
|
|
return DequantizeSigned(data, pos, 359.995f);
|
|
}
|
|
|
|
private void FromBytes(byte[] data, int pos, int length)
|
|
{
|
|
FaceTextures = new SerializableDictionary<uint, TextureEntryFace>();
|
|
DefaultTexture = new TextureEntryFace(null);
|
|
|
|
if (length <= 0)
|
|
return; // No TextureEntry to process
|
|
|
|
uint BitfieldSize = 0;
|
|
uint faceBits = 0;
|
|
int i = pos;
|
|
|
|
//Read TextureID ---------------------------------------
|
|
DefaultTexture.TextureID = new LLUUID(data, i);
|
|
i += 16;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
LLUUID tmpUUID = new LLUUID(data, i);
|
|
i += 16;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).TextureID = tmpUUID;
|
|
}
|
|
//Read RGBA --------------------------------------------
|
|
DefaultTexture.RGBA = (uint)(data[i] + (data[i + 1] << 8) + (data[i + 2] << 16) + (data[i + 3] << 24));
|
|
i += 4;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
uint tmpUint = (uint)(data[i] + (data[i + 1] << 8) + (data[i + 2] << 16) + (data[i + 3] << 24));
|
|
i += 4;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).RGBA = tmpUint;
|
|
}
|
|
//Read RepeatU -----------------------------------------
|
|
DefaultTexture.RepeatU = RepeatFloat(data, i);
|
|
i += 2;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
float tmpFloat = RepeatFloat(data, i);
|
|
i += 2;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).RepeatU = tmpFloat;
|
|
}
|
|
//Read RepeatV -----------------------------------------
|
|
DefaultTexture.RepeatV = RepeatFloat(data, i);
|
|
i += 2;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
float tmpFloat = RepeatFloat(data, i);
|
|
i += 2;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).RepeatV = tmpFloat;
|
|
}
|
|
//Read OffsetU -----------------------------------------
|
|
DefaultTexture.OffsetU = OffsetFloat(data, i);
|
|
i += 2;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
float tmpFloat = OffsetFloat(data, i);
|
|
i += 2;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).OffsetU = tmpFloat;
|
|
}
|
|
//Read OffsetV -----------------------------------------
|
|
DefaultTexture.OffsetV = OffsetFloat(data, i);
|
|
i += 2;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
float tmpFloat = OffsetFloat(data, i);
|
|
i += 2;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).OffsetV = tmpFloat;
|
|
}
|
|
//Read Rotation ----------------------------------------
|
|
DefaultTexture.Rotation = RotationFloat(data, i);
|
|
i += 2;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
float tmpFloat = RotationFloat(data, i);
|
|
i += 2;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).Rotation = tmpFloat;
|
|
}
|
|
//Read Flags1 ------------------------------------------
|
|
DefaultTexture.Flags1 = data[i];
|
|
i++;
|
|
|
|
while (ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
byte tmpByte = data[i];
|
|
i++;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).Flags1 = tmpByte;
|
|
}
|
|
//Read Flags2 ------------------------------------------
|
|
DefaultTexture.Flags2 = data[i];
|
|
i++;
|
|
|
|
while (i - pos < length && ReadFaceBitfield(data, ref i, ref faceBits, ref BitfieldSize))
|
|
{
|
|
byte tmpByte = data[i];
|
|
i++;
|
|
|
|
for (uint face = 0, bit = 1; face < BitfieldSize; face++, bit <<= 1)
|
|
if ((faceBits & bit) != 0)
|
|
CreateFace(face).Flags2 = tmpByte;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A single textured face. Don't instantiate this class yourself, use the
|
|
/// methods in TextureEntry
|
|
/// </summary>
|
|
[Serializable]
|
|
public class TextureEntryFace
|
|
{
|
|
[XmlAttribute("rgba")]
|
|
private uint rgba;
|
|
[XmlAttribute("repeatu")]
|
|
private float repeatU = 1.0f;
|
|
[XmlAttribute("repeatv")]
|
|
private float repeatV = 1.0f;
|
|
[XmlAttribute("offsetu")]
|
|
private float offsetU;
|
|
[XmlAttribute("offsetv")]
|
|
private float offsetV;
|
|
[XmlAttribute("rotation")]
|
|
private float rotation;
|
|
[XmlAttribute("flags1")]
|
|
private byte flags1;
|
|
[XmlAttribute("flags2")]
|
|
private byte flags2;
|
|
[XmlAttribute("textureattributes")]
|
|
private TextureAttributes hasAttribute;
|
|
[XmlText]
|
|
private LLUUID textureID;
|
|
[XmlElement("defaulttexture")]
|
|
private TextureEntryFace DefaultTexture = null;
|
|
|
|
//////////////////////
|
|
///// Properties /////
|
|
//////////////////////
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("rgba")]
|
|
public uint RGBA
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.RGBA) != 0)
|
|
return rgba;
|
|
else
|
|
return DefaultTexture.rgba;
|
|
}
|
|
set
|
|
{
|
|
rgba = value;
|
|
hasAttribute |= TextureAttributes.RGBA;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("repeatu")]
|
|
public float RepeatU
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.RepeatU) != 0)
|
|
return repeatU;
|
|
else
|
|
return DefaultTexture.repeatU;
|
|
}
|
|
set
|
|
{
|
|
repeatU = value;
|
|
hasAttribute |= TextureAttributes.RepeatU;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("repeatv")]
|
|
public float RepeatV
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.RepeatV) != 0)
|
|
return repeatV;
|
|
else
|
|
return DefaultTexture.repeatV;
|
|
}
|
|
set
|
|
{
|
|
repeatV = value;
|
|
hasAttribute |= TextureAttributes.RepeatV;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("offsetu")]
|
|
public float OffsetU
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.OffsetU) != 0)
|
|
return offsetU;
|
|
else
|
|
return DefaultTexture.offsetU;
|
|
}
|
|
set
|
|
{
|
|
offsetU = value;
|
|
hasAttribute |= TextureAttributes.OffsetU;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("offsetv")]
|
|
public float OffsetV
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.OffsetV) != 0)
|
|
return offsetV;
|
|
else
|
|
return DefaultTexture.offsetV;
|
|
}
|
|
set
|
|
{
|
|
offsetV = value;
|
|
hasAttribute |= TextureAttributes.OffsetV;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("rotation")]
|
|
public float Rotation
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.Rotation) != 0)
|
|
return rotation;
|
|
else
|
|
return DefaultTexture.rotation;
|
|
}
|
|
set
|
|
{
|
|
rotation = value;
|
|
hasAttribute |= TextureAttributes.Rotation;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("flags1")]
|
|
public byte Flags1
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.Flags1) != 0)
|
|
return flags1;
|
|
else
|
|
return DefaultTexture.flags1;
|
|
}
|
|
set
|
|
{
|
|
flags1 = value;
|
|
hasAttribute |= TextureAttributes.Flags1;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlAttribute("flags2")]
|
|
public byte Flags2
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.Flags2) != 0)
|
|
return flags2;
|
|
else
|
|
return DefaultTexture.flags2;
|
|
}
|
|
set
|
|
{
|
|
flags2 = value;
|
|
hasAttribute |= TextureAttributes.Flags2;
|
|
}
|
|
}
|
|
|
|
/// <summary></summary>
|
|
[XmlElement("id")]
|
|
public LLUUID TextureID
|
|
{
|
|
get
|
|
{
|
|
if ((hasAttribute & TextureAttributes.TextureID) != 0)
|
|
return textureID;
|
|
else
|
|
return DefaultTexture.textureID;
|
|
}
|
|
set
|
|
{
|
|
textureID = value;
|
|
hasAttribute |= TextureAttributes.TextureID;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////
|
|
///// End of properties /////
|
|
/////////////////////////////
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public TextureEntryFace()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Contains the definition for individual faces
|
|
/// </summary>
|
|
/// <param name="defaultTexture"></param>
|
|
public TextureEntryFace(TextureEntryFace defaultTexture)
|
|
{
|
|
DefaultTexture = defaultTexture;
|
|
if (DefaultTexture == null)
|
|
hasAttribute = TextureAttributes.All;
|
|
else
|
|
hasAttribute = TextureAttributes.None;
|
|
}
|
|
|
|
public void ToXml(XmlWriter xmlWriter)
|
|
{
|
|
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
|
|
ns.Add("", "");
|
|
XmlSerializer serializer = new XmlSerializer(typeof(TextureEntryFace));
|
|
serializer.Serialize(xmlWriter, this, ns);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Controls the texture animation of a particular prim
|
|
/// </summary>
|
|
[Serializable]
|
|
public class TextureAnimation
|
|
{
|
|
/// <summary></summary>
|
|
[XmlAttribute("flags"), DefaultValue(0)]
|
|
public uint Flags;
|
|
/// <summary></summary>
|
|
[XmlAttribute("face"), DefaultValue(0)]
|
|
public uint Face;
|
|
/// <summary></summary>
|
|
[XmlAttribute("sizex"), DefaultValue(0)]
|
|
public uint SizeX;
|
|
/// <summary></summary>
|
|
[XmlAttribute("sizey"), DefaultValue(0)]
|
|
public uint SizeY;
|
|
/// <summary></summary>
|
|
[XmlAttribute("start"), DefaultValue(0)]
|
|
public float Start;
|
|
/// <summary></summary>
|
|
[XmlAttribute("length"), DefaultValue(0)]
|
|
public float Length;
|
|
/// <summary></summary>
|
|
[XmlAttribute("rate"), DefaultValue(0)]
|
|
public float Rate;
|
|
|
|
/// <summary>
|
|
/// Default constructor
|
|
/// </summary>
|
|
public TextureAnimation()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <param name="pos"></param>
|
|
public TextureAnimation(byte[] data, int pos)
|
|
{
|
|
FromBytes(data, pos);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public byte[] GetBytes()
|
|
{
|
|
byte[] bytes = new byte[0];
|
|
// FIXME: Finish TextureAnimation GetBytes() function
|
|
return bytes;
|
|
}
|
|
|
|
private void FromBytes(byte[] data, int pos)
|
|
{
|
|
int i = pos;
|
|
|
|
if (data.Length == 0)
|
|
return;
|
|
|
|
Flags = (uint)data[i++];
|
|
Face = (uint)data[i++];
|
|
SizeX = (uint)data[i++];
|
|
SizeY = (uint)data[i++];
|
|
|
|
if (!BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(data, i, 4);
|
|
Array.Reverse(data, i + 4, 4);
|
|
Array.Reverse(data, i + 8, 4);
|
|
}
|
|
|
|
Start = BitConverter.ToSingle(data, i);
|
|
Length = BitConverter.ToSingle(data, i + 4);
|
|
Rate = BitConverter.ToSingle(data, i + 8);
|
|
}
|
|
}
|
|
}
|
|
}
|