/// <summary>
/// Interpolates a point between two vectors using Linear Interpolation.
/// </summary>
/// <param name="a">First vector</param>
/// <param name="b">Second vector</param>
/// <param name="mu">Value between 0-1 of the interpolation amount</param>
/// <returns></returns>
public static RenderBase.OVector3 interpolateLinear(RenderBase.OVector3 a, RenderBase.OVector3 b, float mu)
{
RenderBase.OVector3 output = new RenderBase.OVector3();
output.x = interpolateLinear(a.x, b.x, mu);
output.y = interpolateLinear(a.y, b.y, mu);
output.z = interpolateLinear(a.z, b.z, mu);
return(output);
}
/// <summary>
/// Interpolates a point between two vectors using Linear Interpolation.
/// </summary>
/// <param name="a">First vector</param>
/// <param name="b">Second vector</param>
/// <param name="mu">Value between 0-1 of the interpolation amount</param>
/// <returns></returns>
public static RenderBase.OVector3 interpolateLinear(RenderBase.OVector3 a, RenderBase.OVector3 b, float mu)
{
RenderBase.OVector3 output = new RenderBase.OVector3();
output.x = interpolateLinear(a.x, b.x, mu);
output.y = interpolateLinear(a.y, b.y, mu);
output.z = interpolateLinear(a.z, b.z, mu);
return output;
}
/// <summary>
/// Loads a BCH file.
/// Note that BCH must start at offset 0x0 (don't try using it for BCHs inside containers).
/// </summary>
/// <param name="data">Memory Stream of the BCH file. The Stream will not be usable after</param>
/// <returns></returns>
public static RenderBase.OModelGroup load(MemoryStream data)
{
BinaryReader input = new BinaryReader(data);
BinaryWriter writer = new BinaryWriter(data);
RenderBase.OModelGroup models = new RenderBase.OModelGroup();
//Primary header
bchHeader header = new bchHeader();
header.magic = IOUtils.readString(input, 0);
data.Seek(4, SeekOrigin.Current);
header.backwardCompatibility = input.ReadByte();
header.forwardCompatibility = input.ReadByte();
header.version = input.ReadUInt16();
header.mainHeaderOffset = input.ReadUInt32();
header.stringTableOffset = input.ReadUInt32();
header.gpuCommandsOffset = input.ReadUInt32();
header.dataOffset = input.ReadUInt32();
if (header.backwardCompatibility > 0x20) header.dataExtendedOffset = input.ReadUInt32();
header.relocationTableOffset = input.ReadUInt32();
header.mainHeaderLength = input.ReadUInt32();
header.stringTableLength = input.ReadUInt32();
header.gpuCommandsLength = input.ReadUInt32();
header.dataLength = input.ReadUInt32();
if (header.backwardCompatibility > 0x20) header.dataExtendedLength = input.ReadUInt32();
header.relocationTableLength = input.ReadUInt32();
header.uninitializedDataSectionLength = input.ReadUInt32();
header.uninitializedDescriptionSectionLength = input.ReadUInt32();
if (header.backwardCompatibility > 7)
{
header.flags = input.ReadUInt16();
header.addressCount = input.ReadUInt16();
}
//Transform relative offsets to absolute offsets, also add extra bits if necessary.
//The game does this on RAM after the BCH is loaded, so offsets to data is absolute and points to VRAM.
for (uint o = header.relocationTableOffset; o < header.relocationTableOffset + header.relocationTableLength; o += 4)
{
data.Seek(o, SeekOrigin.Begin);
uint value = input.ReadUInt32();
uint offset = value & 0x1ffffff;
byte flags = (byte)(value >> 25);
switch (flags)
{
case 0:
data.Seek((offset * 4) + header.mainHeaderOffset, SeekOrigin.Begin);
writer.Write(peek(input) + header.mainHeaderOffset);
break;
case 1:
data.Seek(offset + header.mainHeaderOffset, SeekOrigin.Begin);
writer.Write(peek(input) + header.stringTableOffset);
break;
case 2:
data.Seek((offset * 4) + header.mainHeaderOffset, SeekOrigin.Begin);
writer.Write(peek(input) + header.gpuCommandsOffset);
break;
case 7:
case 0xc:
data.Seek((offset * 4) + header.mainHeaderOffset, SeekOrigin.Begin);
writer.Write(peek(input) + header.dataOffset);
break;
}
//The moron that designed the format used different flags on different versions, instead of keeping compatibility.
data.Seek((offset * 4) + header.gpuCommandsOffset, SeekOrigin.Begin);
if (header.backwardCompatibility < 6)
{
switch (flags)
{
case 0x23: writer.Write(peek(input) + header.dataOffset); break; //Texture
case 0x25: writer.Write(peek(input) + header.dataOffset); break; //Vertex
case 0x26: writer.Write(((peek(input) + header.dataOffset) & 0x7fffffff) | 0x80000000); break; //Index 16 bits mode
case 0x27: writer.Write((peek(input) + header.dataOffset) & 0x7fffffff); break; //Index 8 bits mode
}
}
else if (header.backwardCompatibility < 8)
{
switch (flags)
{
case 0x24: writer.Write(peek(input) + header.dataOffset); break; //Texture
case 0x26: writer.Write(peek(input) + header.dataOffset); break; //Vertex
case 0x27: writer.Write(((peek(input) + header.dataOffset) & 0x7fffffff) | 0x80000000); break; //Index 16 bits mode
case 0x28: writer.Write((peek(input) + header.dataOffset) & 0x7fffffff); break; //Index 8 bits mode
}
}
else if (header.backwardCompatibility < 0x21)
{
switch (flags)
{
case 0x25: writer.Write(peek(input) + header.dataOffset); break; //Texture
case 0x27: writer.Write(peek(input) + header.dataOffset); break; //Vertex
case 0x28: writer.Write(((peek(input) + header.dataOffset) & 0x7fffffff) | 0x80000000); break; //Index 16 bits mode
case 0x29: writer.Write((peek(input) + header.dataOffset) & 0x7fffffff); break; //Index 8 bits mode
}
}
else
{
switch (flags)
{
case 0x25: writer.Write(peek(input) + header.dataOffset); break; //Texture
case 0x26: writer.Write(peek(input) + header.dataOffset); break; //Vertex relative to Data Offset
case 0x27: writer.Write(((peek(input) + header.dataOffset) & 0x7fffffff) | 0x80000000); break; //Index 16 bits mode relative to Data Offset
case 0x28: writer.Write((peek(input) + header.dataOffset) & 0x7fffffff); break; //Index 8 bits mode relative to Data Offset
case 0x2b: writer.Write(peek(input) + header.dataExtendedOffset); break; //Vertex relative to Data Extended Offset
case 0x2c: writer.Write(((peek(input) + header.dataExtendedOffset) & 0x7fffffff) | 0x80000000); break; //Index 16 bits mode relative to Data Extended Offset
case 0x2d: writer.Write((peek(input) + header.dataExtendedOffset) & 0x7fffffff); break; //Index 8 bits mode relative to Data Extended Offset
}
}
}
//Content header
data.Seek(header.mainHeaderOffset, SeekOrigin.Begin);
bchContentHeader contentHeader = new bchContentHeader
{
modelsPointerTableOffset = input.ReadUInt32(),
modelsPointerTableEntries = input.ReadUInt32(),
modelsNameOffset = input.ReadUInt32(),
materialsPointerTableOffset = input.ReadUInt32(),
materialsPointerTableEntries = input.ReadUInt32(),
materialsNameOffset = input.ReadUInt32(),
shadersPointerTableOffset = input.ReadUInt32(),
shadersPointerTableEntries = input.ReadUInt32(),
shadersNameOffset = input.ReadUInt32(),
texturesPointerTableOffset = input.ReadUInt32(),
texturesPointerTableEntries = input.ReadUInt32(),
texturesNameOffset = input.ReadUInt32(),
materialsLUTPointerTableOffset = input.ReadUInt32(),
materialsLUTPointerTableEntries = input.ReadUInt32(),
materialsLUTNameOffset = input.ReadUInt32(),
lightsPointerTableOffset = input.ReadUInt32(),
lightsPointerTableEntries = input.ReadUInt32(),
lightsNameOffset = input.ReadUInt32(),
camerasPointerTableOffset = input.ReadUInt32(),
camerasPointerTableEntries = input.ReadUInt32(),
camerasNameOffset = input.ReadUInt32(),
fogsPointerTableOffset = input.ReadUInt32(),
fogsPointerTableEntries = input.ReadUInt32(),
fogsNameOffset = input.ReadUInt32(),
skeletalAnimationsPointerTableOffset = input.ReadUInt32(),
skeletalAnimationsPointerTableEntries = input.ReadUInt32(),
skeletalAnimationsNameOffset = input.ReadUInt32(),
materialAnimationsPointerTableOffset = input.ReadUInt32(),
materialAnimationsPointerTableEntries = input.ReadUInt32(),
materialAnimationsNameOffset = input.ReadUInt32(),
visibilityAnimationsPointerTableOffset = input.ReadUInt32(),
visibilityAnimationsPointerTableEntries = input.ReadUInt32(),
visibilityAnimationsNameOffset = input.ReadUInt32(),
lightAnimationsPointerTableOffset = input.ReadUInt32(),
lightAnimationsPointerTableEntries = input.ReadUInt32(),
lightAnimationsNameOffset = input.ReadUInt32(),
cameraAnimationsPointerTableOffset = input.ReadUInt32(),
cameraAnimationsPointerTableEntries = input.ReadUInt32(),
cameraAnimationsNameOffset = input.ReadUInt32(),
fogAnimationsPointerTableOffset = input.ReadUInt32(),
fogAnimationsPointerTableEntries = input.ReadUInt32(),
fogAnimationsNameOffset = input.ReadUInt32(),
scenePointerTableOffset = input.ReadUInt32(),
scenePointerTableEntries = input.ReadUInt32(),
sceneNameOffset = input.ReadUInt32()
};
//Note: NameOffset are PATRICIA trees
//Shaders
for (int index = 0; index < contentHeader.shadersPointerTableEntries; index++)
{
data.Seek(contentHeader.shadersPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
uint shaderDataOffset = input.ReadUInt32();
uint shaderDataLength = input.ReadUInt32();
}
//Textures
for (int index = 0; index < contentHeader.texturesPointerTableEntries; index++)
{
data.Seek(contentHeader.texturesPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
uint textureCommandsOffset = input.ReadUInt32();
uint textureCommandsWordCount = input.ReadUInt32();
data.Seek(0x14, SeekOrigin.Current);
string textureName = readString(input);
data.Seek(textureCommandsOffset, SeekOrigin.Begin);
PICACommandReader textureCommands = new PICACommandReader(data, textureCommandsWordCount);
//Note: It have textures for the 3 texture units.
//The other texture units are used with textureCoordinate1 and 2.
data.Seek(textureCommands.getTexUnit0Address(), SeekOrigin.Begin);
Size textureSize = textureCommands.getTexUnit0Size();
byte[] buffer = new byte[textureSize.Width * textureSize.Height * 4];
input.Read(buffer, 0, buffer.Length);
Bitmap texture = TextureCodec.decode(
buffer,
textureSize.Width,
textureSize.Height,
textureCommands.getTexUnit0Format());
models.texture.Add(new RenderBase.OTexture(texture, textureName));
}
//LookUp Tables
for (int index = 0; index < contentHeader.materialsLUTPointerTableEntries; index++)
{
data.Seek(contentHeader.materialsLUTPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
input.ReadUInt32();
uint samplersCount = input.ReadUInt32();
string name = readString(input);
RenderBase.OLookUpTable table = new RenderBase.OLookUpTable();
table.name = name;
for (int i = 0; i < samplersCount; i++)
{
RenderBase.OLookUpTableSampler sampler = new RenderBase.OLookUpTableSampler();
input.ReadUInt32();
uint tableOffset = input.ReadUInt32();
uint tableWordCount = input.ReadUInt32();
sampler.name = readString(input);
long dataPosition = data.Position;
data.Seek(tableOffset, SeekOrigin.Begin);
PICACommandReader lutCommands = new PICACommandReader(data, tableWordCount);
sampler.table = lutCommands.getFSHLookUpTable();
table.sampler.Add(sampler);
data.Seek(dataPosition, SeekOrigin.Begin);
}
models.lookUpTable.Add(table);
}
//Lights
for (int index = 0; index < contentHeader.lightsPointerTableEntries; index++)
{
data.Seek(contentHeader.lightsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OLight light = new RenderBase.OLight();
light.name = readString(input);
light.transformScale = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
light.transformRotate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
light.transformTranslate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
uint lightFlags = input.ReadUInt32();
switch (lightFlags & 0xf)
{
case 1: light.lightUse = RenderBase.OLightUse.hemiSphere; break;
case 2: light.lightUse = RenderBase.OLightUse.ambient; break;
case 5:
case 6:
case 7:
light.lightUse = RenderBase.OLightUse.vertex;
switch (lightFlags & 0xf)
{
case 5: light.lightType = RenderBase.OLightType.directional; break;
case 6: light.lightType = RenderBase.OLightType.point; break;
case 7: light.lightType = RenderBase.OLightType.spot; break;
}
break;
case 9:
case 0xa:
case 0xb:
light.lightUse = RenderBase.OLightUse.fragment;
switch (lightFlags & 0xf)
{
case 9: light.lightType = RenderBase.OLightType.directional; break;
case 0xa: light.lightType = RenderBase.OLightType.point; break;
case 0xb: light.lightType = RenderBase.OLightType.spot; break;
}
break;
default: Debug.WriteLine(string.Format("BCH: Warning - Unknow Light Flags {0}", lightFlags.ToString("X8"))); break;
}
light.isLightEnabled = (lightFlags & 0x100) > 0;
light.isTwoSideDiffuse = (lightFlags & 0x10000) > 0;
light.isDistanceAttenuationEnabled = (lightFlags & 0x20000) > 0;
light.angleSampler.input = (RenderBase.OFragmentSamplerInput)((lightFlags >> 24) & 0xf);
light.angleSampler.scale = (RenderBase.OFragmentSamplerScale)((lightFlags >> 28) & 0xf);
input.ReadUInt32();
switch (light.lightUse)
{
case RenderBase.OLightUse.hemiSphere:
light.groundColor = MeshUtils.getColorFloat(input);
light.skyColor = MeshUtils.getColorFloat(input);
light.direction = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
light.lerpFactor = input.ReadSingle();
break;
case RenderBase.OLightUse.ambient: light.ambient = MeshUtils.getColor(input); break;
case RenderBase.OLightUse.vertex:
light.ambient = MeshUtils.getColorFloat(input);
light.diffuse = MeshUtils.getColorFloat(input);
light.direction = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
light.distanceAttenuationConstant = input.ReadSingle();
light.distanceAttenuationLinear = input.ReadSingle();
light.distanceAttenuationQuadratic = input.ReadSingle();
light.spotExponent = input.ReadSingle();
light.spotCutoffAngle = input.ReadSingle();
break;
case RenderBase.OLightUse.fragment:
light.ambient = MeshUtils.getColor(input);
light.diffuse = MeshUtils.getColor(input);
light.specular0 = MeshUtils.getColor(input);
light.specular1 = MeshUtils.getColor(input);
light.direction = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
input.ReadUInt32();
input.ReadUInt32();
light.attenuationStart = input.ReadSingle();
light.attenuationEnd = input.ReadSingle();
light.distanceSampler.tableName = readString(input);
light.distanceSampler.samplerName = readString(input);
light.angleSampler.tableName = readString(input);
light.angleSampler.samplerName = readString(input);
break;
}
models.light.Add(light);
}
//Cameras
for (int index = 0; index < contentHeader.camerasPointerTableEntries; index++)
{
data.Seek(contentHeader.camerasPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OCamera camera = new RenderBase.OCamera();
camera.name = readString(input);
camera.transformScale = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
camera.transformRotate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
camera.transformTranslate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
uint cameraFlags = input.ReadUInt32();
camera.isInheritingTargetRotate = (cameraFlags & 0x10000) > 0;
camera.isInheritingTargetTranslate = (cameraFlags & 0x20000) > 0;
camera.isInheritingUpRotate = (cameraFlags & 0x40000) > 0;
camera.view = (RenderBase.OCameraView)(cameraFlags & 0xf);
camera.projection = (RenderBase.OCameraProjection)((cameraFlags >> 8) & 0xf);
input.ReadSingle();
uint viewOffset = input.ReadUInt32();
uint projectionOffset = input.ReadUInt32();
data.Seek(viewOffset, SeekOrigin.Begin);
camera.target = new RenderBase.OVector3();
camera.rotation = new RenderBase.OVector3();
camera.upVector = new RenderBase.OVector3();
RenderBase.OVector3 target = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
switch (camera.view)
{
case RenderBase.OCameraView.aimTarget: camera.target = target; camera.twist = input.ReadSingle(); break;
case RenderBase.OCameraView.lookAtTarget: camera.target = target; camera.upVector = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle()); break;
case RenderBase.OCameraView.rotate: camera.rotation = target; break;
}
data.Seek(projectionOffset, SeekOrigin.Begin);
camera.zNear = input.ReadSingle();
camera.zFar = input.ReadSingle();
camera.aspectRatio = input.ReadSingle();
switch (camera.projection)
{
case RenderBase.OCameraProjection.perspective: camera.fieldOfViewY = input.ReadSingle(); break;
case RenderBase.OCameraProjection.orthogonal: camera.height = input.ReadSingle(); break;
}
models.camera.Add(camera);
}
//Fogs
for (int index = 0; index < contentHeader.fogsPointerTableEntries; index++)
{
data.Seek(contentHeader.fogsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OFog fog = new RenderBase.OFog();
fog.name = readString(input);
fog.transformScale = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
fog.transformRotate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
fog.transformTranslate = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
uint fogFlags = input.ReadUInt32();
fog.fogUpdater = (RenderBase.OFogUpdater)(fogFlags & 0xf);
fog.isZFlip = (fogFlags & 0x100) > 0;
fog.isAttenuateDistance = (fogFlags & 0x200) > 0;
fog.fogColor = MeshUtils.getColor(input);
fog.minFogDepth = input.ReadSingle();
fog.maxFogDepth = input.ReadSingle();
fog.fogDensity = input.ReadSingle();
models.fog.Add(fog);
}
//Skeletal Animations
for (int index = 0; index < contentHeader.skeletalAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.skeletalAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OSkeletalAnimation skeletalAnimation = new RenderBase.OSkeletalAnimation();
skeletalAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
skeletalAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
skeletalAnimation.frameSize = input.ReadSingle();
uint boneTableOffset = input.ReadUInt32();
uint boneTableEntries = input.ReadUInt32();
uint metaDataPointerOffset = input.ReadUInt32();
if (metaDataPointerOffset != 0)
{
data.Seek(metaDataPointerOffset, SeekOrigin.Begin);
skeletalAnimation.userData = getMetaData(input);
}
for (int i = 0; i < boneTableEntries; i++)
{
data.Seek(boneTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OSkeletalAnimationBone bone = new RenderBase.OSkeletalAnimationBone();
data.Seek(offset, SeekOrigin.Begin);
bone.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
input.ReadUInt32();
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
switch (segmentType)
{
case RenderBase.OSegmentType.transform:
data.Seek(offset + 0x18, SeekOrigin.Begin);
uint notExistMask = 0x80000;
uint constantMask = 0x200;
for (int j = 0; j < 2; j++)
{
for (int axis = 0; axis < 3; axis++)
{
bool notExist = (flags & notExistMask) > 0;
bool constant = (flags & constantMask) > 0;
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
frame.exists = !notExist;
if (frame.exists)
{
if (constant)
{
frame.interpolation = RenderBase.OInterpolationMode.linear;
frame.keyFrames.Add(new RenderBase.OAnimationKeyFrame(input.ReadSingle(), 0));
}
else
{
uint frameOffset = input.ReadUInt32();
long position = data.Position;
data.Seek(frameOffset, SeekOrigin.Begin);
getAnimationKeyFrame(input, frame);
data.Seek(position, SeekOrigin.Begin);
}
}
else
data.Seek(4, SeekOrigin.Current);
if (j == 0)
{
switch (axis)
{
case 0: bone.rotationX = frame; break;
case 1: bone.rotationY = frame; break;
case 2: bone.rotationZ = frame; break;
}
}
else
{
switch (axis)
{
case 0: bone.translationX = frame; break;
case 1: bone.translationY = frame; break;
case 2: bone.translationZ = frame; break;
}
}
notExistMask <<= 1;
constantMask <<= 1;
}
constantMask <<= 1;
}
break;
case RenderBase.OSegmentType.transformQuaternion:
bone.isFrameFormat = true;
long originalPos = data.Position;
uint rotationOffset = input.ReadUInt32();
uint translationOffset = input.ReadUInt32();
if ((flags & 0x10) == 0)
{
bone.rotationQuaternion.exists = true;
data.Seek(rotationOffset, SeekOrigin.Begin);
if ((flags & 2) > 0)
{
bone.rotationQuaternion.vector.Add(new RenderBase.OVector4(
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle()));
}
else
{
bone.rotationQuaternion.startFrame = input.ReadSingle();
bone.rotationQuaternion.endFrame = input.ReadSingle();
uint rotationFlags = input.ReadUInt32();
uint rotationDataOffset = input.ReadUInt32();
uint rotationEntries = input.ReadUInt32();
data.Seek(rotationDataOffset, SeekOrigin.Begin);
for (int j = 0; j < rotationEntries; j++)
{
bone.rotationQuaternion.vector.Add(new RenderBase.OVector4(
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle()));
}
}
}
if ((flags & 8) == 0)
{
bone.translation.exists = true;
data.Seek(translationOffset, SeekOrigin.Begin);
if ((flags & 1) > 0)
{
bone.translation.vector.Add(new RenderBase.OVector4(
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle(),
0));
}
else
{
bone.translation.startFrame = input.ReadSingle();
bone.translation.endFrame = input.ReadSingle();
uint translationFlags = input.ReadUInt32();
uint translationDataOffset = input.ReadUInt32();
uint translationEntries = input.ReadUInt32();
data.Seek(translationDataOffset, SeekOrigin.Begin);
for (int j = 0; j < translationEntries; j++)
{
bone.translation.vector.Add(new RenderBase.OVector4(
input.ReadSingle(),
input.ReadSingle(),
input.ReadSingle(),
0));
}
}
}
break;
case RenderBase.OSegmentType.transformMatrix:
bone.isFullBakedFormat = true;
input.ReadUInt32();
uint matrixOffset = input.ReadUInt32();
uint entries = input.ReadUInt32();
data.Seek(matrixOffset, SeekOrigin.Begin);
for (int j = 0; j < entries; j++)
{
RenderBase.OMatrix transform = new RenderBase.OMatrix();
transform.M11 = input.ReadSingle();
transform.M21 = input.ReadSingle();
transform.M31 = input.ReadSingle();
transform.M41 = input.ReadSingle();
transform.M12 = input.ReadSingle();
transform.M22 = input.ReadSingle();
transform.M32 = input.ReadSingle();
transform.M42 = input.ReadSingle();
transform.M13 = input.ReadSingle();
transform.M23 = input.ReadSingle();
transform.M33 = input.ReadSingle();
transform.M43 = input.ReadSingle();
bone.transform.Add(transform);
}
break;
default: throw new Exception(string.Format("BCH: Unknow Segment Type {0} on Skeletal Animation bone {1}! STOP!", segmentType, bone.name));
}
skeletalAnimation.bone.Add(bone);
}
models.skeletalAnimation.list.Add(skeletalAnimation);
}
//Material Animations
for (int index = 0; index < contentHeader.materialAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.materialAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OMaterialAnimation materialAnimation = new RenderBase.OMaterialAnimation();
materialAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
materialAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
materialAnimation.frameSize = input.ReadSingle();
uint dataTableOffset = input.ReadUInt32();
uint dataTableEntries = input.ReadUInt32();
input.ReadUInt32();
uint textureNameTableOffset = input.ReadUInt32();
uint textureNameTableEntries = input.ReadUInt32();
data.Seek(textureNameTableOffset, SeekOrigin.Begin);
for (int i = 0; i < textureNameTableEntries; i++)
{
string name = readString(input);
materialAnimation.textureName.Add(name);
}
for (int i = 0; i < dataTableEntries; i++)
{
data.Seek(dataTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OMaterialAnimationData animationData = new RenderBase.OMaterialAnimationData();
data.Seek(offset, SeekOrigin.Begin);
animationData.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
animationData.type = (RenderBase.OMaterialAnimationType)(animationTypeFlags & 0xff);
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
int segmentCount = 0;
switch (segmentType)
{
case RenderBase.OSegmentType.rgbaColor: segmentCount = 4; break;
case RenderBase.OSegmentType.vector2: segmentCount = 2; break;
case RenderBase.OSegmentType.single: segmentCount = 1; break;
case RenderBase.OSegmentType.integer: segmentCount = 1; break;
}
for (int j = 0; j < segmentCount; j++)
{
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
data.Seek(offset + 0xc + (j * 4), SeekOrigin.Begin);
frame.exists = (flags & (0x100 << j)) == 0;
bool constant = (flags & (1 << j)) > 0;
if (frame.exists)
{
if (constant)
{
frame.interpolation = RenderBase.OInterpolationMode.linear;
frame.keyFrames.Add(new RenderBase.OAnimationKeyFrame(input.ReadSingle(), 0));
}
else
{
uint frameOffset = input.ReadUInt32();
data.Seek(frameOffset, SeekOrigin.Begin);
getAnimationKeyFrame(input, frame);
}
}
animationData.frameList.Add(frame);
}
materialAnimation.data.Add(animationData);
}
models.materialAnimation.list.Add(materialAnimation);
}
//Visibility Animations
for (int index = 0; index < contentHeader.visibilityAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.visibilityAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OVisibilityAnimation visibilityAnimation = new RenderBase.OVisibilityAnimation();
visibilityAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
visibilityAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
visibilityAnimation.frameSize = input.ReadSingle();
uint dataTableOffset = input.ReadUInt32();
uint dataTableEntries = input.ReadUInt32();
input.ReadUInt32();
input.ReadUInt32();
for (int i = 0; i < dataTableEntries; i++)
{
data.Seek(dataTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OVisibilityAnimationData animationData = new RenderBase.OVisibilityAnimationData();
data.Seek(offset, SeekOrigin.Begin);
animationData.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
if (segmentType == RenderBase.OSegmentType.boolean)
{
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
if (segmentType == RenderBase.OSegmentType.boolean) frame = getAnimationKeyFrameBool(input);
animationData.visibilityList = frame;
}
visibilityAnimation.data.Add(animationData);
}
models.visibilityAnimation.list.Add(visibilityAnimation);
}
//Light Animations
for (int index = 0; index < contentHeader.lightAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.lightAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OLightAnimation lightAnimation = new RenderBase.OLightAnimation();
lightAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
lightAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
lightAnimation.frameSize = input.ReadSingle();
uint dataTableOffset = input.ReadUInt32();
uint dataTableEntries = input.ReadUInt32();
input.ReadUInt32();
uint typeFlags = input.ReadUInt32();
lightAnimation.lightType = (RenderBase.OLightType)((typeFlags & 3) - 1);
lightAnimation.lightUse = (RenderBase.OLightUse)((typeFlags >> 2) & 3);
for (int i = 0; i < dataTableEntries; i++)
{
data.Seek(dataTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OLightAnimationData animationData = new RenderBase.OLightAnimationData();
data.Seek(offset, SeekOrigin.Begin);
animationData.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
animationData.type = (RenderBase.OLightAnimationType)(animationTypeFlags & 0xff);
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
int segmentCount = 0;
switch (segmentType)
{
case RenderBase.OSegmentType.transform: segmentCount = 9; break;
case RenderBase.OSegmentType.rgbaColor: segmentCount = 4; break;
case RenderBase.OSegmentType.vector3: segmentCount = 3; break;
case RenderBase.OSegmentType.single: segmentCount = 1; break;
case RenderBase.OSegmentType.boolean: segmentCount = 1; break;
}
uint constantMask = 0x40;
for (int j = 0; j < segmentCount; j++)
{
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
data.Seek(offset + 0xc + (j * 4), SeekOrigin.Begin);
frame.exists = ((flags >> (segmentType == RenderBase.OSegmentType.transform ? 16 : 8)) & (1 << j)) == 0;
if (frame.exists)
{
if (segmentType == RenderBase.OSegmentType.boolean)
{
frame = getAnimationKeyFrameBool(input);
}
else
{
bool constant;
if (segmentType == RenderBase.OSegmentType.transform)
{
constant = (flags & constantMask) > 0;
if (j == 5)
constantMask <<= 2;
else
constantMask <<= 1;
}
else
constant = (flags & (1 << j)) > 0;
if (constant)
{
frame.interpolation = RenderBase.OInterpolationMode.linear;
frame.keyFrames.Add(new RenderBase.OAnimationKeyFrame(input.ReadSingle(), 0.0f));
}
else
{
uint frameOffset = input.ReadUInt32();
data.Seek(frameOffset, SeekOrigin.Begin);
getAnimationKeyFrame(input, frame);
}
}
}
animationData.frameList.Add(frame);
}
lightAnimation.data.Add(animationData);
}
models.lightAnimation.list.Add(lightAnimation);
}
//Camera Animations
for (int index = 0; index < contentHeader.cameraAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.cameraAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OCameraAnimation cameraAnimation = new RenderBase.OCameraAnimation();
cameraAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
cameraAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
cameraAnimation.frameSize = input.ReadSingle();
uint dataTableOffset = input.ReadUInt32();
uint dataTableEntries = input.ReadUInt32();
input.ReadUInt32();
uint modeFlags = input.ReadUInt32();
cameraAnimation.viewMode = (RenderBase.OCameraView)(modeFlags & 0xf);
cameraAnimation.projectionMode = (RenderBase.OCameraProjection)((modeFlags >> 8) & 0xf);
for (int i = 0; i < dataTableEntries; i++)
{
data.Seek(dataTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OCameraAnimationData animationData = new RenderBase.OCameraAnimationData();
data.Seek(offset, SeekOrigin.Begin);
animationData.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
animationData.type = (RenderBase.OCameraAnimationType)(animationTypeFlags & 0xff);
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
int segmentCount = 0;
switch (segmentType)
{
case RenderBase.OSegmentType.transform: segmentCount = 9; break;
case RenderBase.OSegmentType.vector3: segmentCount = 3; break;
case RenderBase.OSegmentType.single: segmentCount = 1; break;
}
uint constantMask = 0x40;
for (int j = 0; j < segmentCount; j++)
{
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
data.Seek(offset + 0xc + (j * 4), SeekOrigin.Begin);
frame.exists = ((flags >> (segmentType == RenderBase.OSegmentType.transform ? 16 : 8)) & (1 << j)) == 0;
bool constant;
if (segmentType == RenderBase.OSegmentType.transform)
{
constant = (flags & constantMask) > 0;
if (j == 5)
constantMask <<= 2;
else
constantMask <<= 1;
}
else
constant = (flags & (1 << j)) > 0;
if (frame.exists)
{
if (constant)
{
frame.interpolation = RenderBase.OInterpolationMode.linear;
frame.keyFrames.Add(new RenderBase.OAnimationKeyFrame(input.ReadSingle(), 0.0f));
}
else
{
uint frameOffset = input.ReadUInt32();
data.Seek(frameOffset, SeekOrigin.Begin);
getAnimationKeyFrame(input, frame);
}
}
animationData.frameList.Add(frame);
}
cameraAnimation.data.Add(animationData);
}
models.cameraAnimation.list.Add(cameraAnimation);
}
//Fog Animations
for (int index = 0; index < contentHeader.fogAnimationsPointerTableEntries; index++)
{
data.Seek(contentHeader.fogAnimationsPointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OFogAnimation fogAnimation = new RenderBase.OFogAnimation();
fogAnimation.name = readString(input);
uint animationFlags = input.ReadUInt32();
fogAnimation.loopMode = (RenderBase.OLoopMode)(animationFlags & 1);
fogAnimation.frameSize = input.ReadSingle();
uint dataTableOffset = input.ReadUInt32();
uint dataTableEntries = input.ReadUInt32();
input.ReadUInt32();
input.ReadUInt32();
for (int i = 0; i < dataTableEntries; i++)
{
data.Seek(dataTableOffset + (i * 4), SeekOrigin.Begin);
uint offset = input.ReadUInt32();
RenderBase.OFogAnimationData animationData = new RenderBase.OFogAnimationData();
data.Seek(offset, SeekOrigin.Begin);
animationData.name = readString(input);
uint animationTypeFlags = input.ReadUInt32();
uint flags = input.ReadUInt32();
RenderBase.OSegmentType segmentType = (RenderBase.OSegmentType)((animationTypeFlags >> 16) & 0xf);
int segmentCount = segmentType == RenderBase.OSegmentType.rgbaColor ? 4 : 0;
for (int j = 0; j < segmentCount; j++)
{
RenderBase.OAnimationKeyFrameGroup frame = new RenderBase.OAnimationKeyFrameGroup();
data.Seek(offset + 0xc + (j * 4), SeekOrigin.Begin);
frame.exists = ((flags >> 8) & (1 << j)) == 0;
if (frame.exists)
{
bool constant = (flags & (1 << j)) > 0;
if (constant)
{
frame.interpolation = RenderBase.OInterpolationMode.linear;
frame.keyFrames.Add(new RenderBase.OAnimationKeyFrame(input.ReadSingle(), 0.0f));
}
else
{
uint frameOffset = input.ReadUInt32();
data.Seek(frameOffset, SeekOrigin.Begin);
getAnimationKeyFrame(input, frame);
}
}
animationData.colorList.Add(frame);
}
fogAnimation.data.Add(animationData);
}
models.fogAnimation.list.Add(fogAnimation);
}
//Scene Environment
for (int index = 0; index < contentHeader.scenePointerTableEntries; index++)
{
data.Seek(contentHeader.scenePointerTableOffset + (index * 4), SeekOrigin.Begin);
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
RenderBase.OScene scene = new RenderBase.OScene();
scene.name = readString(input);
uint cameraReferenceOffset = input.ReadUInt32();
uint cameraReferenceEntries = input.ReadUInt32();
uint lightReferenceOffset = input.ReadUInt32();
uint lightReferenceEntries = input.ReadUInt32();
uint fogReferenceOffset = input.ReadUInt32();
uint fogReferenceEntries = input.ReadUInt32();
data.Seek(cameraReferenceOffset, SeekOrigin.Begin);
for (int i = 0; i < cameraReferenceEntries; i++)
{
RenderBase.OSceneReference reference = new RenderBase.OSceneReference();
reference.slotIndex = input.ReadUInt32();
reference.name = readString(input);
scene.cameras.Add(reference);
}
data.Seek(lightReferenceOffset, SeekOrigin.Begin);
for (int i = 0; i < lightReferenceEntries; i++)
{
RenderBase.OSceneReference reference = new RenderBase.OSceneReference();
reference.slotIndex = input.ReadUInt32();
reference.name = readString(input);
scene.lights.Add(reference);
}
data.Seek(fogReferenceOffset, SeekOrigin.Begin);
for (int i = 0; i < fogReferenceEntries; i++)
{
RenderBase.OSceneReference reference = new RenderBase.OSceneReference();
reference.slotIndex = input.ReadUInt32();
reference.name = readString(input);
scene.fogs.Add(reference);
}
}
//Models
for (int modelIndex = 0; modelIndex < contentHeader.modelsPointerTableEntries; modelIndex++)
{
RenderBase.OModel model = new RenderBase.OModel();
data.Seek(contentHeader.modelsPointerTableOffset + (modelIndex * 4), SeekOrigin.Begin);
uint objectsHeaderOffset = input.ReadUInt32();
//Objects header
data.Seek(objectsHeaderOffset, SeekOrigin.Begin);
bchModelHeader modelHeader;
modelHeader.flags = input.ReadByte();
modelHeader.skeletonScalingType = input.ReadByte();
modelHeader.silhouetteMaterialEntries = input.ReadUInt16();
modelHeader.worldTransform = new RenderBase.OMatrix();
modelHeader.worldTransform.M11 = input.ReadSingle();
modelHeader.worldTransform.M21 = input.ReadSingle();
modelHeader.worldTransform.M31 = input.ReadSingle();
modelHeader.worldTransform.M41 = input.ReadSingle();
modelHeader.worldTransform.M12 = input.ReadSingle();
modelHeader.worldTransform.M22 = input.ReadSingle();
modelHeader.worldTransform.M32 = input.ReadSingle();
modelHeader.worldTransform.M42 = input.ReadSingle();
modelHeader.worldTransform.M13 = input.ReadSingle();
modelHeader.worldTransform.M23 = input.ReadSingle();
modelHeader.worldTransform.M33 = input.ReadSingle();
modelHeader.worldTransform.M43 = input.ReadSingle();
modelHeader.materialsTableOffset = input.ReadUInt32();
modelHeader.materialsTableEntries = input.ReadUInt32();
modelHeader.materialsNameOffset = input.ReadUInt32();
modelHeader.verticesTableOffset = input.ReadUInt32();
modelHeader.verticesTableEntries = input.ReadUInt32();
data.Seek(header.backwardCompatibility > 6 ? 0x28 : 0x20, SeekOrigin.Current);
modelHeader.skeletonOffset = input.ReadUInt32();
modelHeader.skeletonEntries = input.ReadUInt32();
modelHeader.skeletonNameOffset = input.ReadUInt32();
modelHeader.objectsNodeVisibilityOffset = input.ReadUInt32();
modelHeader.objectsNodeCount = input.ReadUInt32();
modelHeader.modelName = readString(input);
modelHeader.objectsNodeNameEntries = input.ReadUInt32();
modelHeader.objectsNodeNameOffset = input.ReadUInt32();
input.ReadUInt32(); //0x0
modelHeader.metaDataPointerOffset = input.ReadUInt32();
model.transform = modelHeader.worldTransform;
model.name = modelHeader.modelName;
string[] objectName = new string[modelHeader.objectsNodeNameEntries];
data.Seek(modelHeader.objectsNodeNameOffset, SeekOrigin.Begin);
int rootReferenceBit = input.ReadInt32(); //Radix tree
uint rootLeftNode = input.ReadUInt16();
uint rootRightNode = input.ReadUInt16();
uint rootNameOffset = input.ReadUInt32();
for (int i = 0; i < modelHeader.objectsNodeNameEntries; i++)
{
int referenceBit = input.ReadInt32();
ushort leftNode = input.ReadUInt16();
ushort rightNode = input.ReadUInt16();
objectName[i] = readString(input);
}
//Materials
for (int index = 0; index < modelHeader.materialsTableEntries; index++)
{
//Nota: As versões mais antigas tinham o Coordinator já no header do material.
//As versões mais recentes tem uma seção reservada só pra ele, por isso possuem tamanho do header menor.
if (header.backwardCompatibility < 0x21)
data.Seek(modelHeader.materialsTableOffset + (index * 0x58), SeekOrigin.Begin);
else
data.Seek(modelHeader.materialsTableOffset + (index * 0x2c), SeekOrigin.Begin);
RenderBase.OMaterial material = new RenderBase.OMaterial();
uint materialParametersOffset = input.ReadUInt32();
input.ReadUInt32(); //TODO
input.ReadUInt32();
input.ReadUInt32();
uint textureCommandsOffset = input.ReadUInt32();
uint textureCommandsWordCount = input.ReadUInt32();
uint materialMapperOffset = 0;
if (header.backwardCompatibility < 0x21)
{
materialMapperOffset = (uint)data.Position;
data.Seek(0x30, SeekOrigin.Current);
}
else
materialMapperOffset = input.ReadUInt32();
material.name0 = readString(input);
material.name1 = readString(input);
material.name2 = readString(input);
material.name = readString(input);
//Parameters
//Same pointer of Materials section. Why?
if (materialParametersOffset != 0)
{
data.Seek(materialParametersOffset, SeekOrigin.Begin);
uint hash = input.ReadUInt32();
ushort materialFlags = input.ReadUInt16();
material.isFragmentLightEnabled = (materialFlags & 1) > 0;
material.isVertexLightEnabled = (materialFlags & 2) > 0;
material.isHemiSphereLightEnabled = (materialFlags & 4) > 0;
material.isHemiSphereOcclusionEnabled = (materialFlags & 8) > 0;
material.isFogEnabled = (materialFlags & 0x10) > 0;
material.rasterization.isPolygonOffsetEnabled = (materialFlags & 0x20) > 0;
ushort fragmentFlags = input.ReadUInt16();
material.fragmentShader.bump.isBumpRenormalize = (fragmentFlags & 1) > 0;
material.fragmentShader.lighting.isClampHighLight = (fragmentFlags & 2) > 0;
material.fragmentShader.lighting.isDistribution0Enabled = (fragmentFlags & 4) > 0;
material.fragmentShader.lighting.isDistribution1Enabled = (fragmentFlags & 8) > 0;
material.fragmentShader.lighting.isGeometryFactor0Enabled = (fragmentFlags & 0x10) > 0;
material.fragmentShader.lighting.isGeometryFactor1Enabled = (fragmentFlags & 0x20) > 0;
material.fragmentShader.lighting.isReflectionEnabled = (fragmentFlags & 0x40) > 0;
RenderBase.OBlendMode blendMode = (RenderBase.OBlendMode)((fragmentFlags >> 10) & 3);
input.ReadUInt32();
for (int i = 0; i < 3; i++)
{
RenderBase.OTextureCoordinator coordinator;
uint projectionAndCamera = input.ReadUInt32();
coordinator.projection = (RenderBase.OTextureProjection)((projectionAndCamera >> 16) & 0xff);
coordinator.referenceCamera = projectionAndCamera >> 24;
coordinator.scaleU = input.ReadSingle();
coordinator.scaleV = input.ReadSingle();
coordinator.rotate = input.ReadSingle();
coordinator.translateU = input.ReadSingle();
coordinator.translateV = input.ReadSingle();
material.textureCoordinator[i] = coordinator;
}
material.lightSetIndex = input.ReadUInt16();
material.fogIndex = input.ReadUInt16();
material.materialColor.emission = MeshUtils.getColor(input);
material.materialColor.ambient = MeshUtils.getColor(input);
material.materialColor.diffuse = MeshUtils.getColor(input);
material.materialColor.specular0 = MeshUtils.getColor(input);
material.materialColor.specular1 = MeshUtils.getColor(input);
material.materialColor.constant0 = MeshUtils.getColor(input);
material.materialColor.constant1 = MeshUtils.getColor(input);
material.materialColor.constant2 = MeshUtils.getColor(input);
material.materialColor.constant3 = MeshUtils.getColor(input);
material.materialColor.constant4 = MeshUtils.getColor(input);
material.materialColor.constant5 = MeshUtils.getColor(input);
material.fragmentOperation.blend.blendColor = MeshUtils.getColor(input);
material.materialColor.colorScale = input.ReadSingle();
input.ReadUInt32(); //TODO: Figure out
input.ReadUInt32();
input.ReadUInt32();
input.ReadUInt32();
input.ReadUInt32();
input.ReadUInt32();
uint fragmentData = input.ReadUInt32();
material.fragmentShader.bump.texture = (RenderBase.OBumpTexture)(fragmentData >> 24);
material.fragmentShader.bump.mode = (RenderBase.OBumpMode)((fragmentData >> 16) & 0xff);
material.fragmentShader.lighting.fresnelConfig = (RenderBase.OFresnelConfig)((fragmentData >> 8) & 0xff);
material.fragmentShader.layerConfig = fragmentData & 0xff;
//Some Fragment Lighting related commands... This seems a bit out of place.
long position = data.Position;
PICACommandReader fshLightingCommands = new PICACommandReader(data, 6, true);
PICACommand.fragmentSamplerAbsolute sAbs = fshLightingCommands.getReflectanceSamplerAbsolute();
material.fragmentShader.lighting.reflectanceRSampler.isAbsolute = sAbs.r;
material.fragmentShader.lighting.reflectanceGSampler.isAbsolute = sAbs.g;
material.fragmentShader.lighting.reflectanceBSampler.isAbsolute = sAbs.b;
material.fragmentShader.lighting.distribution0Sampler.isAbsolute = sAbs.d0;
material.fragmentShader.lighting.distribution1Sampler.isAbsolute = sAbs.d1;
material.fragmentShader.lighting.fresnelSampler.isAbsolute = sAbs.fresnel;
PICACommand.fragmentSamplerInput sInput = fshLightingCommands.getReflectanceSamplerInput();
material.fragmentShader.lighting.reflectanceRSampler.input = sInput.r;
material.fragmentShader.lighting.reflectanceGSampler.input = sInput.g;
material.fragmentShader.lighting.reflectanceBSampler.input = sInput.b;
material.fragmentShader.lighting.distribution0Sampler.input = sInput.d0;
material.fragmentShader.lighting.distribution1Sampler.input = sInput.d1;
material.fragmentShader.lighting.fresnelSampler.input = sInput.fresnel;
PICACommand.fragmentSamplerScale sScale = fshLightingCommands.getReflectanceSamplerScale();
material.fragmentShader.lighting.reflectanceRSampler.scale = sScale.r;
material.fragmentShader.lighting.reflectanceGSampler.scale = sScale.g;
material.fragmentShader.lighting.reflectanceBSampler.scale = sScale.b;
material.fragmentShader.lighting.distribution0Sampler.scale = sScale.d0;
material.fragmentShader.lighting.distribution1Sampler.scale = sScale.d1;
material.fragmentShader.lighting.fresnelSampler.scale = sScale.fresnel;
data.Seek(position + (4 * 6), SeekOrigin.Begin); //Just to be sure ;)
RenderBase.OConstantColor[] constantList = new RenderBase.OConstantColor[6];
uint constantColor = input.ReadUInt32();
for (int i = 0; i < 6; i++) constantList[i] = (RenderBase.OConstantColor)((constantColor >> (i * 4)) & 0xf);
material.rasterization.polygonOffsetUnit = input.ReadSingle();
uint fshCommandsOffset = input.ReadUInt32();
uint fshCommandsWordCount = input.ReadUInt32();
input.ReadUInt32();
material.fragmentShader.lighting.distribution0Sampler.tableName = readString(input);
material.fragmentShader.lighting.distribution1Sampler.tableName = readString(input);
material.fragmentShader.lighting.fresnelSampler.tableName = readString(input);
material.fragmentShader.lighting.reflectanceRSampler.tableName = readString(input);
material.fragmentShader.lighting.reflectanceGSampler.tableName = readString(input);
material.fragmentShader.lighting.reflectanceBSampler.tableName = readString(input);
material.fragmentShader.lighting.distribution0Sampler.samplerName = readString(input);
material.fragmentShader.lighting.distribution1Sampler.samplerName = readString(input);
material.fragmentShader.lighting.fresnelSampler.samplerName = readString(input);
material.fragmentShader.lighting.reflectanceRSampler.samplerName = readString(input);
material.fragmentShader.lighting.reflectanceGSampler.samplerName = readString(input);
material.fragmentShader.lighting.reflectanceBSampler.samplerName = readString(input);
material.shaderReference = new RenderBase.OReference(readString(input));
material.modelReference = new RenderBase.OReference(readString(input));
//User Data
if (header.backwardCompatibility > 6)
{
uint metaDataPointerOffset = input.ReadUInt32();
if (metaDataPointerOffset != 0)
{
data.Seek(metaDataPointerOffset, SeekOrigin.Begin);
material.userData = getMetaData(input);
}
}
//Mapper
data.Seek(materialMapperOffset, SeekOrigin.Begin);
for (int i = 0; i < 3; i++)
{
RenderBase.OTextureMapper mapper;
uint wrapAndMagFilter = input.ReadUInt32();
uint levelOfDetailAndMinFilter = input.ReadUInt32();
mapper.wrapU = (RenderBase.OTextureWrap)((wrapAndMagFilter >> 8) & 0xff);
mapper.wrapV = (RenderBase.OTextureWrap)((wrapAndMagFilter >> 16) & 0xff);
mapper.magFilter = (RenderBase.OTextureMagFilter)(wrapAndMagFilter >> 24);
mapper.minFilter = (RenderBase.OTextureMinFilter)(levelOfDetailAndMinFilter & 0xff);
mapper.minLOD = (levelOfDetailAndMinFilter >> 8) & 0xff; //max 232
mapper.LODBias = input.ReadSingle();
mapper.borderColor = MeshUtils.getColor(input);
material.textureMapper[i] = mapper;
}
//Fragment Shader commands
data.Seek(fshCommandsOffset, SeekOrigin.Begin);
PICACommandReader fshCommands = new PICACommandReader(data, fshCommandsWordCount);
for (byte stage = 0; stage < 6; stage++) material.fragmentShader.textureCombiner[stage] = fshCommands.getTevStage(stage);
material.fragmentShader.bufferColor = fshCommands.getFragmentBufferColor();
material.fragmentOperation.blend = fshCommands.getBlendOperation();
material.fragmentOperation.blend.logicalOperation = fshCommands.getColorLogicOperation();
material.fragmentShader.alphaTest = fshCommands.getAlphaTest();
material.fragmentOperation.stencil = fshCommands.getStencilTest();
material.fragmentOperation.depth = fshCommands.getDepthTest();
material.rasterization.cullMode = fshCommands.getCullMode();
material.fragmentOperation.blend.mode = blendMode;
}
model.material.Add(material);
}
//Skeleton
data.Seek(modelHeader.skeletonOffset, SeekOrigin.Begin);
for (int index = 0; index < modelHeader.skeletonEntries; index++)
{
RenderBase.OBone bone = new RenderBase.OBone();
uint boneFlags = input.ReadUInt32();
bone.billboardMode = (RenderBase.OBillboardMode)((boneFlags >> 16) & 0xf);
bone.isSegmentScaleCompensate = (boneFlags & 0x00400000) > 0;
bone.parentId = input.ReadInt16();
ushort boneSpacer = input.ReadUInt16();
bone.scale = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
bone.rotation = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
bone.translation = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
bone.absoluteScale = new RenderBase.OVector3(bone.scale);
RenderBase.OMatrix boneMatrix = new RenderBase.OMatrix();
boneMatrix.M11 = input.ReadSingle();
boneMatrix.M21 = input.ReadSingle();
boneMatrix.M31 = input.ReadSingle();
boneMatrix.M41 = input.ReadSingle();
boneMatrix.M12 = input.ReadSingle();
boneMatrix.M22 = input.ReadSingle();
boneMatrix.M32 = input.ReadSingle();
boneMatrix.M42 = input.ReadSingle();
boneMatrix.M13 = input.ReadSingle();
boneMatrix.M23 = input.ReadSingle();
boneMatrix.M33 = input.ReadSingle();
boneMatrix.M43 = input.ReadSingle();
bone.name = readString(input);
uint metaDataPointerOffset = input.ReadUInt32();
if (metaDataPointerOffset != 0)
{
long position = data.Position;
data.Seek(metaDataPointerOffset, SeekOrigin.Begin);
bone.userData = getMetaData(input);
data.Seek(position, SeekOrigin.Begin);
}
model.skeleton.Add(bone);
}
List<RenderBase.OMatrix> skeletonTransform = new List<RenderBase.OMatrix>();
for (int index = 0; index < modelHeader.skeletonEntries; index++)
{
RenderBase.OMatrix transform = new RenderBase.OMatrix();
transformSkeleton(model.skeleton, index, ref transform);
skeletonTransform.Add(transform);
}
data.Seek(modelHeader.objectsNodeVisibilityOffset, SeekOrigin.Begin);
uint nodeVisibility = input.ReadUInt32();
//Vertices header
data.Seek(modelHeader.verticesTableOffset, SeekOrigin.Begin);
List<bchObjectEntry> objects = new List<bchObjectEntry>();
for (int index = 0; index < modelHeader.verticesTableEntries; index++)
{
bchObjectEntry objectEntry = new bchObjectEntry();
objectEntry.materialId = input.ReadUInt16();
ushort flags = input.ReadUInt16();
if (header.backwardCompatibility != 8) objectEntry.isSilhouette = (flags & 1) > 0;
objectEntry.nodeId = input.ReadUInt16();
objectEntry.renderPriority = input.ReadUInt16();
objectEntry.vshAttributesBufferCommandsOffset = input.ReadUInt32(); //Buffer 0
objectEntry.vshAttributesBufferCommandsWordCount = input.ReadUInt32();
objectEntry.facesHeaderOffset = input.ReadUInt32();
objectEntry.facesHeaderEntries = input.ReadUInt32();
objectEntry.vshExtraAttributesBufferCommandsOffset = input.ReadUInt32(); //Buffers 1-11
objectEntry.vshExtraAttributesBufferCommandsWordCount = input.ReadUInt32();
objectEntry.centerVector = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
objectEntry.flagsOffset = input.ReadUInt32();
input.ReadUInt32(); //ex: 0x0 fixo
objectEntry.boundingBoxOffset = input.ReadUInt32();
objects.Add(objectEntry);
}
for (int objIndex = 0; objIndex < objects.Count; objIndex++)
{
if (objects[objIndex].isSilhouette) continue; //TODO: Figure out for what "Silhouette" is used.
RenderBase.OMesh obj = new RenderBase.OMesh();
obj.materialId = objects[objIndex].materialId;
obj.renderPriority = objects[objIndex].renderPriority;
if (objects[objIndex].nodeId < objectName.Length) obj.name = objectName[objects[objIndex].nodeId]; else obj.name = "mesh" + objIndex.ToString();
obj.isVisible = (nodeVisibility & (1 << objects[objIndex].nodeId)) > 0;
//Vertices
data.Seek(objects[objIndex].vshAttributesBufferCommandsOffset, SeekOrigin.Begin);
PICACommandReader vshCommands = new PICACommandReader(data, objects[objIndex].vshAttributesBufferCommandsWordCount);
Stack<float> vshAttributesUniformReg6 = vshCommands.getVSHFloatUniformData(6);
Stack<float> vshAttributesUniformReg7 = vshCommands.getVSHFloatUniformData(7);
RenderBase.OVector4 positionOffset = new RenderBase.OVector4(
vshAttributesUniformReg6.Pop(),
vshAttributesUniformReg6.Pop(),
vshAttributesUniformReg6.Pop(),
vshAttributesUniformReg6.Pop());
float texture0Scale = vshAttributesUniformReg7.Pop();
float texture1Scale = vshAttributesUniformReg7.Pop();
float texture2Scale = vshAttributesUniformReg7.Pop();
float boneWeightScale = vshAttributesUniformReg7.Pop();
float positionScale = vshAttributesUniformReg7.Pop();
float normalScale = vshAttributesUniformReg7.Pop();
float tangentScale = vshAttributesUniformReg7.Pop();
float colorScale = vshAttributesUniformReg7.Pop();
//Faces
uint facesCount = objects[objIndex].facesHeaderEntries;
bool hasFaces = facesCount > 0;
uint facesTableOffset = 0;
if (!hasFaces)
{
data.Seek(modelHeader.verticesTableOffset + modelHeader.verticesTableEntries * 0x38, SeekOrigin.Begin);
data.Seek(objIndex * 0x1c + 0x10, SeekOrigin.Current);
facesTableOffset = input.ReadUInt32();
facesCount = input.ReadUInt32();
}
for (uint f = 0; f < facesCount; f++)
{
RenderBase.OSkinningMode skinningMode = RenderBase.OSkinningMode.none;
List<ushort> nodeList = new List<ushort>();
uint idxBufferOffset;
PICACommand.indexBufferFormat idxBufferFormat;
uint idxBufferTotalVertices;
if (hasFaces)
{
uint baseOffset = objects[objIndex].facesHeaderOffset + f * 0x34;
data.Seek(baseOffset, SeekOrigin.Begin);
skinningMode = (RenderBase.OSkinningMode)input.ReadUInt16();
ushort nodeIdEntries = input.ReadUInt16();
for (int n = 0; n < nodeIdEntries; n++) nodeList.Add(input.ReadUInt16());
data.Seek(baseOffset + 0x2c, SeekOrigin.Begin);
uint faceHeaderOffset = input.ReadUInt32();
uint faceHeaderWordCount = input.ReadUInt32();
data.Seek(faceHeaderOffset, SeekOrigin.Begin);
PICACommandReader idxCommands = new PICACommandReader(data, faceHeaderWordCount);
idxBufferOffset = idxCommands.getIndexBufferAddress();
idxBufferFormat = idxCommands.getIndexBufferFormat();
idxBufferTotalVertices = idxCommands.getIndexBufferTotalVertices();
}
else
{
data.Seek(facesTableOffset + f * 8, SeekOrigin.Begin);
idxBufferOffset = input.ReadUInt32();
idxBufferFormat = PICACommand.indexBufferFormat.unsignedShort;
idxBufferTotalVertices = input.ReadUInt32();
}
//Carregamento de dados relacionados ao Vertex Shader
uint vshAttributesBufferOffset = vshCommands.getVSHAttributesBufferAddress(0);
uint vshAttributesBufferStride = vshCommands.getVSHAttributesBufferStride(0);
uint vshTotalAttributes = vshCommands.getVSHTotalAttributes(0);
PICACommand.vshAttribute[] vshMainAttributesBufferPermutation = vshCommands.getVSHAttributesBufferPermutation();
uint[] vshAttributesBufferPermutation = vshCommands.getVSHAttributesBufferPermutation(0);
PICACommand.attributeFormat[] vshAttributesBufferFormat = vshCommands.getVSHAttributesBufferFormat();
for (int attribute = 0; attribute < vshTotalAttributes; attribute++)
{
switch (vshMainAttributesBufferPermutation[vshAttributesBufferPermutation[attribute]])
{
case PICACommand.vshAttribute.normal: obj.hasNormal = true; break;
case PICACommand.vshAttribute.tangent: obj.hasTangent = true; break;
case PICACommand.vshAttribute.color: obj.hasColor = true; break;
case PICACommand.vshAttribute.textureCoordinate0: obj.texUVCount = Math.Max(obj.texUVCount, 1); break;
case PICACommand.vshAttribute.textureCoordinate1: obj.texUVCount = Math.Max(obj.texUVCount, 2); break;
case PICACommand.vshAttribute.textureCoordinate2: obj.texUVCount = Math.Max(obj.texUVCount, 3); break;
}
}
if (nodeList.Count > 0)
{
obj.hasNode = true;
obj.hasWeight = true;
}
data.Seek(idxBufferOffset, SeekOrigin.Begin);
for (int faceIndex = 0; faceIndex < idxBufferTotalVertices; faceIndex++)
{
ushort index = 0;
switch (idxBufferFormat)
{
case PICACommand.indexBufferFormat.unsignedShort: index = input.ReadUInt16(); break;
case PICACommand.indexBufferFormat.unsignedByte: index = input.ReadByte(); break;
}
long dataPosition = data.Position;
long vertexOffset = vshAttributesBufferOffset + (index * vshAttributesBufferStride);
data.Seek(vertexOffset, SeekOrigin.Begin);
RenderBase.OVertex vertex = new RenderBase.OVertex();
vertex.diffuseColor = 0xffffffff;
for (int attribute = 0; attribute < vshTotalAttributes; attribute++)
{
//gdkchan self note: The Attribute type flags are used for something else on Bone Weight (and bone index?)
PICACommand.vshAttribute att = vshMainAttributesBufferPermutation[vshAttributesBufferPermutation[attribute]];
PICACommand.attributeFormat format = vshAttributesBufferFormat[vshAttributesBufferPermutation[attribute]];
if (att == PICACommand.vshAttribute.boneWeight) format.type = PICACommand.attributeFormatType.unsignedByte;
RenderBase.OVector4 vector = getVector(input, format);
switch (att)
{
case PICACommand.vshAttribute.position:
float x = (vector.x * positionScale) + positionOffset.x;
float y = (vector.y * positionScale) + positionOffset.y;
float z = (vector.z * positionScale) + positionOffset.z;
vertex.position = new RenderBase.OVector3(x, y, z);
break;
case PICACommand.vshAttribute.normal:
vertex.normal = new RenderBase.OVector3(vector.x * normalScale, vector.y * normalScale, vector.z * normalScale);
break;
case PICACommand.vshAttribute.tangent:
vertex.tangent = new RenderBase.OVector3(vector.x * tangentScale, vector.y * tangentScale, vector.z * tangentScale);
break;
case PICACommand.vshAttribute.color:
uint r = MeshUtils.saturate((vector.x * colorScale) * 0xff);
uint g = MeshUtils.saturate((vector.y * colorScale) * 0xff);
uint b = MeshUtils.saturate((vector.z * colorScale) * 0xff);
uint a = MeshUtils.saturate((vector.w * colorScale) * 0xff);
vertex.diffuseColor = b | (g << 8) | (r << 16) | (a << 24);
break;
case PICACommand.vshAttribute.textureCoordinate0:
vertex.texture0 = new RenderBase.OVector2(vector.x * texture0Scale, vector.y * texture0Scale);
break;
case PICACommand.vshAttribute.textureCoordinate1:
vertex.texture1 = new RenderBase.OVector2(vector.x * texture1Scale, vector.y * texture1Scale);
break;
case PICACommand.vshAttribute.textureCoordinate2:
vertex.texture2 = new RenderBase.OVector2(vector.x * texture2Scale, vector.y * texture2Scale);
break;
case PICACommand.vshAttribute.boneIndex:
vertex.node.Add(nodeList[(int)vector.x]);
if (skinningMode == RenderBase.OSkinningMode.smoothSkinning)
{
if (format.attributeLength > 0) vertex.node.Add(nodeList[(int)vector.y]);
if (format.attributeLength > 1) vertex.node.Add(nodeList[(int)vector.z]);
if (format.attributeLength > 2) vertex.node.Add(nodeList[(int)vector.w]);
}
break;
case PICACommand.vshAttribute.boneWeight:
vertex.weight.Add(vector.x * boneWeightScale);
if (skinningMode == RenderBase.OSkinningMode.smoothSkinning)
{
if (format.attributeLength > 0) vertex.weight.Add(vector.y * boneWeightScale);
if (format.attributeLength > 1) vertex.weight.Add(vector.z * boneWeightScale);
if (format.attributeLength > 2) vertex.weight.Add(vector.w * boneWeightScale);
}
break;
}
}
//If the node list have 4 or less bones, then there is no need to store the indices per vertex
//Instead, the entire list is used, since it supports up to 4 bones.
if (vertex.node.Count == 0 && nodeList.Count <= 4)
{
for (int n = 0; n < nodeList.Count; n++) vertex.node.Add(nodeList[n]);
if (vertex.weight.Count == 0) vertex.weight.Add(1);
}
if (skinningMode != RenderBase.OSkinningMode.smoothSkinning && vertex.node.Count > 0)
{
//Note: Rigid skinning can have only one bone per vertex
//Note2: Vertex with Rigid skinning seems to be always have meshes centered, so is necessary to make them follow the skeleton
if (vertex.weight.Count == 0) vertex.weight.Add(1);
vertex.position = RenderBase.OVector3.transform(vertex.position, skeletonTransform[vertex.node[0]]);
}
MeshUtils.calculateBounds(model, vertex);
obj.vertices.Add(vertex);
data.Seek(dataPosition, SeekOrigin.Begin);
}
}
//Bounding box
if (objects[objIndex].boundingBoxOffset != 0)
{
data.Seek(objects[objIndex].boundingBoxOffset, SeekOrigin.Begin);
uint bBoxDataOffset = input.ReadUInt32();
uint bBoxEntries = input.ReadUInt32();
uint bBoxNameOffset = input.ReadUInt32();
for (int index = 0; index < bBoxEntries; index++)
{
data.Seek(bBoxDataOffset + (index * 0xc), SeekOrigin.Begin);
RenderBase.OOrientedBoundingBox bBox = new RenderBase.OOrientedBoundingBox();
bBox.name = readString(input);
uint flags = input.ReadUInt32();
uint dataOffset = input.ReadUInt32();
data.Seek(dataOffset, SeekOrigin.Begin);
bBox.centerPosition = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
bBox.orientationMatrix.M11 = input.ReadSingle();
bBox.orientationMatrix.M21 = input.ReadSingle();
bBox.orientationMatrix.M31 = input.ReadSingle();
bBox.orientationMatrix.M12 = input.ReadSingle();
bBox.orientationMatrix.M22 = input.ReadSingle();
bBox.orientationMatrix.M32 = input.ReadSingle();
bBox.orientationMatrix.M13 = input.ReadSingle();
bBox.orientationMatrix.M23 = input.ReadSingle();
bBox.orientationMatrix.M33 = input.ReadSingle();
bBox.size = new RenderBase.OVector3(input.ReadSingle(), input.ReadSingle(), input.ReadSingle());
obj.boundingBox.Add(bBox);
}
}
model.mesh.Add(obj);
}
if (modelHeader.metaDataPointerOffset != 0)
{
data.Seek(modelHeader.metaDataPointerOffset, SeekOrigin.Begin);
model.userData = getMetaData(input);
}
for (int index = 0; index < modelHeader.skeletonEntries; index++)
{
scaleSkeleton(model.skeleton, index, index);
}
models.model.Add(model);
}
data.Close();
return models;
}
/// <summary>
/// Imports a Wavefront OBJ model from file.
/// </summary>
/// <param name="fileName">The complete file name</param>
/// <returns></returns>
public RenderBase.OModelGroup import(string fileName)
{
RenderBase.OModelGroup output = new RenderBase.OModelGroup();
RenderBase.OModel model = new RenderBase.OModel();
string obj = File.ReadAllText(fileName);
List <RenderBase.OVector3> vertices = new List <RenderBase.OVector3>();
List <RenderBase.OVector3> normals = new List <RenderBase.OVector3>();
List <RenderBase.OVector2> uvs = new List <RenderBase.OVector2>();
List <RenderBase.OVertex> currVertices = new List <RenderBase.OVertex>();
string name = string.Empty, oldName;
string[] lines = obj.Split((char)0xa);
foreach (string l in lines)
{
string line = l.Trim();
string[] lineParams = Regex.Split(line, "\\s+");
switch (lineParams[0])
{
case "v":
case "vn":
RenderBase.OVector3 pvec = new RenderBase.OVector3();
pvec.x = float.Parse(lineParams[1], CultureInfo.InvariantCulture);
pvec.y = float.Parse(lineParams[2], CultureInfo.InvariantCulture);
pvec.z = float.Parse(lineParams[3], CultureInfo.InvariantCulture);
if (lineParams[0] == "v")
{
vertices.Add(pvec);
}
else
{
normals.Add(pvec);
}
break;
case "vt":
RenderBase.OVector2 tvec = new RenderBase.OVector2();
tvec.x = float.Parse(lineParams[1], CultureInfo.InvariantCulture);
tvec.y = float.Parse(lineParams[2], CultureInfo.InvariantCulture);
uvs.Add(tvec);
break;
case "f":
string[][] vtx = new string[lineParams.Length - 1][];
for (int i = 0; i < lineParams.Length - 1; i++)
{
vtx[i] = lineParams[i + 1].Split('/');
}
for (int i = 0; i < lineParams.Length - 1; i++)
{
RenderBase.OVertex vertex = new RenderBase.OVertex();
vertex.position = vertices[int.Parse(vtx[i][0]) - 1];
if (vtx[i].Length > 1 && vtx[i][1] != string.Empty)
{
vertex.texture0 = uvs[int.Parse(vtx[i][1]) - 1];
}
if (vtx[i].Length > 2)
{
vertex.normal = normals[int.Parse(vtx[i][2]) - 1];
}
vertex.diffuseColor = 0xffffffff;
if (i > 2)
{
currVertices.Add(currVertices[currVertices.Count - 3]);
currVertices.Add(currVertices[currVertices.Count - 2]);
currVertices.Add(vertex);
}
else
{
currVertices.Add(vertex);
}
}
break;
case "g":
oldName = name;
if (lineParams.Length > 1)
{
name = lineParams[1];
}
else
{
name = "mesh";
}
if (currVertices.Count > 0)
{
RenderBase.OMesh mesh = new RenderBase.OMesh();
mesh.vertices = currVertices;
mesh.name = oldName;
mesh.hasNormal = true;
mesh.texUVCount = 1;
model.mesh.Add(mesh);
currVertices = new List <RenderBase.OVertex>();
}
break;
}
}
if (currVertices.Count > 0)
{
RenderBase.OMesh mesh = new RenderBase.OMesh();
mesh.vertices = currVertices;
mesh.name = name;
mesh.hasNormal = true;
mesh.texUVCount = 1;
model.mesh.Add(mesh);
}
model.material.Add(new RenderBase.OMaterial());
output.model.Add(model);
return(output);
}
/// <summary>
/// Renders a single frame of the scene.
/// </summary>
public void render()
{
device.Clear(ClearFlags.Stencil | ClearFlags.Target | ClearFlags.ZBuffer, cfgBackColor, 1f, 15);
device.SetTexture(0, null);
device.BeginScene();
float fovy = (float)Math.PI / 4;
float aspectRatio = (float)pParams.BackBufferWidth / pParams.BackBufferHeight;
device.Transform.Projection = Matrix.PerspectiveFovLH(fovy, aspectRatio, 0.01f, 1000f);
device.Transform.View = Matrix.LookAtLH(
new Vector3(0f, 0f, 20f),
new Vector3(0f, 0f, 0f),
new Vector3(0f, 1f, 0f));
//View
RenderBase.OVector3 minVector = new RenderBase.OVector3();
RenderBase.OVector3 maxVector = new RenderBase.OVector3();
if (currentModel > -1)
{
minVector = models.model[currentModel].minVector;
maxVector = models.model[currentModel].maxVector;
}
float minSize = Math.Min(Math.Min(minVector.x, minVector.y), minVector.z);
float maxSize = Math.Max(Math.Max(maxVector.x, maxVector.y), maxVector.z);
float scale = (10f / (maxSize - minSize)); //Try to adjust to screen
if (maxSize - minSize == 0) scale = 1;
Matrix centerMatrix = Matrix.Translation(
-(minVector.x + maxVector.x) / 2,
-(minVector.y + maxVector.y) / 2,
-(minVector.z + maxVector.z) / 2);
Matrix translationMatrix = Matrix.Translation(
(-translation.X / 50) / scale,
(translation.Y / 50) / scale,
zoom / scale);
Matrix baseTransform = Matrix.Identity;
baseTransform *= Matrix.RotationY(rotation.Y) * Matrix.RotationX(rotation.X);
baseTransform *= centerMatrix * translationMatrix * Matrix.Scaling(-scale, scale, scale);
//Grid
if (cfgShowGuidelines)
{
resetRenderState();
device.Transform.World = baseTransform;
device.VertexFormat = CustomVertex.PositionColored.Format;
using (VertexBuffer buffer = new VertexBuffer(typeof(CustomVertex.PositionColored), gridBuffer.Length, device, Usage.None, CustomVertex.PositionColored.Format, Pool.Managed))
{
buffer.SetData(gridBuffer, 0, LockFlags.None);
device.SetStreamSource(0, buffer, 0);
device.DrawPrimitives(PrimitiveType.LineList, 0, gridBuffer.Length / 2);
}
}
if (fragmentShaderMode)
{
fragmentShader.Begin(0);
fragmentShader.SetValue("world", device.Transform.World);
fragmentShader.SetValue("view", device.Transform.View);
fragmentShader.SetValue("projection", device.Transform.Projection);
fragmentShader.SetValue("lights[0].pos", new Vector4(0, -10, -10, 0));
fragmentShader.SetValue("lights[0].ambient", new Vector4(0.1f, 0.1f, 0.1f, 1));
fragmentShader.SetValue("lights[0].diffuse", new Vector4(1, 1, 1, 1));
fragmentShader.SetValue("lights[0].specular", new Vector4(1, 1, 1, 1));
fragmentShader.SetValue("numLights", 1);
}
if (cfgWireframeMode)
device.RenderState.FillMode = FillMode.WireFrame;
else
device.RenderState.FillMode = FillMode.Solid;
if (currentModel > -1)
{
RenderBase.OModel mdl = models.model[currentModel];
device.Transform.World = getMatrix(mdl.transform) * baseTransform;
#region "Skeletal Animation"
Matrix[] animationSkeletonTransform = new Matrix[mdl.skeleton.Count];
if (ctrlSA.animate)
{
Matrix[] skeletonTransform = new Matrix[mdl.skeleton.Count];
for (int index = 0; index < mdl.skeleton.Count; index++)
{
skeletonTransform[index] = Matrix.Identity;
transformSkeleton(mdl.skeleton, index, ref skeletonTransform[index]);
}
List<RenderBase.OSkeletalAnimationBone> bone = ((RenderBase.OSkeletalAnimation)models.skeletalAnimation.list[ctrlSA.CurrentAnimation]).bone;
List<OAnimationBone> frameAnimationSkeleton = new List<OAnimationBone>();
for (int index = 0; index < mdl.skeleton.Count; index++)
{
OAnimationBone newBone = new OAnimationBone();
newBone.parentId = mdl.skeleton[index].parentId;
newBone.rotationQuaternion = getQuaternion(mdl.skeleton[index].rotation);
newBone.translation = new RenderBase.OVector3(mdl.skeleton[index].translation);
newBone.scale = new RenderBase.OVector3(1, 1, 1);
foreach (RenderBase.OSkeletalAnimationBone b in bone)
{
if (b.name == mdl.skeleton[index].name)
{
if (b.isFullBakedFormat)
{
newBone.hasTransform = true;
newBone.transform = b.transform[(int)ctrlSA.Frame % b.transform.Count];
}
else if (b.isFrameFormat)
{
float fl = (float)Math.Floor(ctrlSA.Frame);
float fr = (float)Math.Ceiling(ctrlSA.Frame);
float mu = ctrlSA.Frame - fl;
if (b.scale.exists)
{
int il = Math.Min((int)fl, b.scale.vector.Count - 1);
int ir = Math.Min((int)fr, b.scale.vector.Count - 1);
RenderBase.OVector4 sl = b.scale.vector[il];
RenderBase.OVector4 sr = b.scale.vector[ir];
RenderBase.OVector4 s = AnimationUtils.interpolateLinear(sl, sr, mu);
newBone.scale = new RenderBase.OVector3(s.x, s.y, s.z);
}
if (b.rotationQuaternion.exists)
{
int il = Math.Min((int)fl, b.rotationQuaternion.vector.Count - 1);
int ir = Math.Min((int)fr, b.rotationQuaternion.vector.Count - 1);
Quaternion ql = getQuaternion(b.rotationQuaternion.vector[il]);
Quaternion qr = getQuaternion(b.rotationQuaternion.vector[ir]);
newBone.rotationQuaternion = Quaternion.Slerp(ql, qr, mu);
}
if (b.translation.exists)
{
int il = Math.Min((int)fl, b.translation.vector.Count - 1);
int ir = Math.Min((int)fr, b.translation.vector.Count - 1);
RenderBase.OVector4 tl = b.translation.vector[il];
RenderBase.OVector4 tr = b.translation.vector[ir];
RenderBase.OVector4 t = AnimationUtils.interpolateLinear(tl, tr, mu);
newBone.translation = new RenderBase.OVector3(t.x, t.y, t.z);
newBone.translation.x *= mdl.skeleton[index].absoluteScale.x;
newBone.translation.y *= mdl.skeleton[index].absoluteScale.y;
newBone.translation.z *= mdl.skeleton[index].absoluteScale.z;
}
}
else
{
//Rotation
float fl = (float)Math.Floor(ctrlSA.Frame);
float fr = (float)Math.Ceiling(ctrlSA.Frame);
float mu = ctrlSA.Frame - fl;
RenderBase.OVector3 vl = new RenderBase.OVector3(mdl.skeleton[index].rotation);
RenderBase.OVector3 vr = new RenderBase.OVector3(mdl.skeleton[index].rotation);
if (b.rotationX.exists)
{
vl.x = AnimationUtils.getKey(b.rotationX, fl);
vr.x = AnimationUtils.getKey(b.rotationX, fr);
}
if (b.rotationY.exists)
{
vl.y = AnimationUtils.getKey(b.rotationY, fl);
vr.y = AnimationUtils.getKey(b.rotationY, fr);
}
if (b.rotationZ.exists)
{
vl.z = AnimationUtils.getKey(b.rotationZ, fl);
vr.z = AnimationUtils.getKey(b.rotationZ, fr);
}
Quaternion ql = getQuaternion(vl);
Quaternion qr = getQuaternion(vr);
newBone.rotationQuaternion = Quaternion.Slerp(ql, qr, mu);
//Translation
if (b.translationX.exists)
{
newBone.translation.x = AnimationUtils.getKey(b.translationX, ctrlSA.Frame);
newBone.translation.x *= mdl.skeleton[index].absoluteScale.x;
}
if (b.translationY.exists)
{
newBone.translation.y = AnimationUtils.getKey(b.translationY, ctrlSA.Frame);
newBone.translation.y *= mdl.skeleton[index].absoluteScale.y;
}
if (b.translationZ.exists)
{
newBone.translation.z = AnimationUtils.getKey(b.translationZ, ctrlSA.Frame);
newBone.translation.z *= mdl.skeleton[index].absoluteScale.z;
}
}
break;
}
}
frameAnimationSkeleton.Add(newBone);
}
for (int index = 0; index < mdl.skeleton.Count; index++)
{
animationSkeletonTransform[index] = Matrix.Identity;
if (frameAnimationSkeleton[index].hasTransform)
animationSkeletonTransform[index] = getMatrix(frameAnimationSkeleton[index].transform);
else
{
animationSkeletonTransform[index] *= Matrix.Scaling(
frameAnimationSkeleton[index].scale.x,
frameAnimationSkeleton[index].scale.y,
frameAnimationSkeleton[index].scale.z);
int id = index;
while (id > -1)
{
RenderBase.OVector3 t = new RenderBase.OVector3(frameAnimationSkeleton[id].translation);
if (frameAnimationSkeleton[id].parentId > -1) t *= frameAnimationSkeleton[frameAnimationSkeleton[id].parentId].scale;
animationSkeletonTransform[index] *= Matrix.RotationQuaternion(frameAnimationSkeleton[id].rotationQuaternion);
animationSkeletonTransform[index] *= Matrix.Translation(t.x, t.y, t.z);
id = frameAnimationSkeleton[id].parentId;
}
}
animationSkeletonTransform[index] = Matrix.Invert(skeletonTransform[index]) * animationSkeletonTransform[index];
}
}
#endregion
for (int objectIndex = 0; objectIndex < mdl.mesh.Count; objectIndex++)
{
RenderBase.OMesh obj = mdl.mesh[objectIndex];
bool isVisible = obj.isVisible;
if (ctrlVA.animate)
{
foreach (RenderBase.OVisibilityAnimationData data in ((RenderBase.OVisibilityAnimation)models.visibilityAnimation.list[ctrlVA.CurrentAnimation]).data)
{
RenderBase.OAnimationKeyFrame frame = AnimationUtils.getLeftFrame(data.visibilityList.keyFrames, ctrlVA.Frame);
if (data.name == obj.name) isVisible = frame.bValue;
}
}
if (!(isVisible || cfgShowAllMeshes)) continue;
RenderBase.OMaterial material = mdl.material[obj.materialId];
#region "Material Animation"
int[] textureId = { -1, -1, -1 };
Color blendColor = material.fragmentOperation.blend.blendColor;
Color[] borderColor = new Color[3];
borderColor[0] = material.textureMapper[0].borderColor;
borderColor[1] = material.textureMapper[1].borderColor;
borderColor[2] = material.textureMapper[2].borderColor;
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)models.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.textureMapper0: getMaterialAnimationInt(data, ref textureId[0]); break;
case RenderBase.OMaterialAnimationType.textureMapper1: getMaterialAnimationInt(data, ref textureId[1]); break;
case RenderBase.OMaterialAnimationType.textureMapper2: getMaterialAnimationInt(data, ref textureId[2]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper0: getMaterialAnimationColor(data, ref borderColor[0]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper1: getMaterialAnimationColor(data, ref borderColor[1]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper2: getMaterialAnimationColor(data, ref borderColor[2]); break;
case RenderBase.OMaterialAnimationType.blendColor: getMaterialAnimationColor(data, ref blendColor); break;
}
}
}
}
#endregion
if (fragmentShaderMode)
{
#region "Shader combiner parameters"
RenderBase.OMaterialColor materialColor = new RenderBase.OMaterialColor();
materialColor = material.materialColor;
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)models.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.constant0: getMaterialAnimationColor(data, ref materialColor.constant0); break;
case RenderBase.OMaterialAnimationType.constant1: getMaterialAnimationColor(data, ref materialColor.constant1); break;
case RenderBase.OMaterialAnimationType.constant2: getMaterialAnimationColor(data, ref materialColor.constant2); break;
case RenderBase.OMaterialAnimationType.constant3: getMaterialAnimationColor(data, ref materialColor.constant3); break;
case RenderBase.OMaterialAnimationType.constant4: getMaterialAnimationColor(data, ref materialColor.constant4); break;
case RenderBase.OMaterialAnimationType.constant5: getMaterialAnimationColor(data, ref materialColor.constant5); break;
case RenderBase.OMaterialAnimationType.diffuse: getMaterialAnimationColor(data, ref materialColor.diffuse); break;
case RenderBase.OMaterialAnimationType.specular0: getMaterialAnimationColor(data, ref materialColor.specular0); break;
case RenderBase.OMaterialAnimationType.specular1: getMaterialAnimationColor(data, ref materialColor.specular1); ; break;
case RenderBase.OMaterialAnimationType.ambient: getMaterialAnimationColor(data, ref materialColor.ambient); break;
}
}
}
}
fragmentShader.SetValue("hasTextures", textures.Count > 0);
fragmentShader.SetValue("uvCount", obj.texUVCount);
fragmentShader.SetValue("isD0Enabled", material.fragmentShader.lighting.isDistribution0Enabled);
fragmentShader.SetValue("isD1Enabled", material.fragmentShader.lighting.isDistribution1Enabled);
fragmentShader.SetValue("isG0Enabled", material.fragmentShader.lighting.isGeometryFactor0Enabled);
fragmentShader.SetValue("isG1Enabled", material.fragmentShader.lighting.isGeometryFactor1Enabled);
fragmentShader.SetValue("isREnabled", material.fragmentShader.lighting.isReflectionEnabled);
fragmentShader.SetValue("bumpIndex", (int)material.fragmentShader.bump.texture);
fragmentShader.SetValue("bumpMode", (int)material.fragmentShader.bump.mode);
fragmentShader.SetValue("mEmissive", getColor(materialColor.emission));
fragmentShader.SetValue("mAmbient", getColor(materialColor.ambient));
fragmentShader.SetValue("mDiffuse", getColor(materialColor.diffuse));
fragmentShader.SetValue("mSpecular", getColor(materialColor.specular0));
fragmentShader.SetValue("hasNormal", obj.hasNormal);
for (int i = 0; i < 6; i++)
{
RenderBase.OTextureCombiner textureCombiner = material.fragmentShader.textureCombiner[i];
fragmentShader.SetValue(string.Format("combiners[{0}].colorCombine", i), (int)textureCombiner.combineRgb);
fragmentShader.SetValue(string.Format("combiners[{0}].alphaCombine", i), (int)textureCombiner.combineAlpha);
fragmentShader.SetValue(string.Format("combiners[{0}].colorScale", i), (float)textureCombiner.rgbScale);
fragmentShader.SetValue(string.Format("combiners[{0}].alphaScale", i), (float)textureCombiner.alphaScale);
for (int j = 0; j < 3; j++)
{
fragmentShader.SetValue(string.Format("combiners[{0}].colorArg[{1}]", i, j), (int)textureCombiner.rgbSource[j]);
fragmentShader.SetValue(string.Format("combiners[{0}].colorOp[{1}]", i, j), (int)textureCombiner.rgbOperand[j]);
fragmentShader.SetValue(string.Format("combiners[{0}].alphaArg[{1}]", i, j), (int)textureCombiner.alphaSource[j]);
fragmentShader.SetValue(string.Format("combiners[{0}].alphaOp[{1}]", i, j), (int)textureCombiner.alphaOperand[j]);
}
Color constantColor = Color.White;
switch (textureCombiner.constantColor)
{
case RenderBase.OConstantColor.ambient: constantColor = materialColor.ambient; break;
case RenderBase.OConstantColor.constant0: constantColor = materialColor.constant0; break;
case RenderBase.OConstantColor.constant1: constantColor = materialColor.constant1; break;
case RenderBase.OConstantColor.constant2: constantColor = materialColor.constant2; break;
case RenderBase.OConstantColor.constant3: constantColor = materialColor.constant3; break;
case RenderBase.OConstantColor.constant4: constantColor = materialColor.constant4; break;
case RenderBase.OConstantColor.constant5: constantColor = materialColor.constant5; break;
case RenderBase.OConstantColor.diffuse: constantColor = materialColor.diffuse; break;
case RenderBase.OConstantColor.emission: constantColor = materialColor.emission; break;
case RenderBase.OConstantColor.specular0: constantColor = materialColor.specular0; break;
case RenderBase.OConstantColor.specular1: constantColor = materialColor.specular1; break;
}
fragmentShader.SetValue(string.Format("combiners[{0}].constant", i), new Vector4(
(float)constantColor.R / 0xff,
(float)constantColor.G / 0xff,
(float)constantColor.B / 0xff,
(float)constantColor.A / 0xff));
}
#endregion
}
int legacyTextureIndex = -1;
int legacyTextureUnit = -1;
for (int i = 0; i < textures.Count; i++)
{
string[] name = new string[3];
name[0] = material.name0;
name[1] = material.name1;
name[2] = material.name2;
if (ctrlMA.animate)
{
RenderBase.OMaterialAnimation ma = (RenderBase.OMaterialAnimation)models.materialAnimation.list[ctrlMA.CurrentAnimation];
for (int j = 0; j < 3; j++) if (textureId[j] > -1) name[j] = ma.textureName[textureId[j]];
}
if (cfgLegacyTexturingMode == 0 && !fragmentShaderMode)
{
if (textures[i].name == name[0])
{
legacyTextureIndex = i;
legacyTextureUnit = 0;
break;
}
}
else
{
for (int j = 0; j < 3; j++)
{
if (fragmentShaderMode)
{
if (textures[i].name == name[j])
{
string shaderTexture = string.Format("texture{0}", j);
fragmentShader.SetValue(shaderTexture, textures[i].texture);
}
}
else
{
if (textures[i].name == name[j] && legacyTextureUnit < j)
{
legacyTextureIndex = i;
legacyTextureUnit = j;
}
}
}
}
}
if (!fragmentShaderMode)
{
if (legacyTextureIndex > -1)
device.SetTexture(0, textures[legacyTextureIndex].texture);
else
device.SetTexture(0, null);
}
#region "Texture Filtering/Addressing Setup"
//Filtering
for (int s = 0; s < 3; s++)
{
RenderBase.OTextureCoordinator coordinator = material.textureCoordinator[s];
Vector2 translate = new Vector2(coordinator.translateU, coordinator.translateV);
Vector2 scaling = new Vector2(coordinator.scaleU, coordinator.scaleV);
if (scaling == Vector2.Empty) scaling = new Vector2(1, 1);
float rotate = coordinator.rotate;
#region "Material Animation"
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)models.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.translateCoordinator0: if (s == 0) getMaterialAnimationVector2(data, ref translate); break; //Translation
case RenderBase.OMaterialAnimationType.translateCoordinator1: if (s == 1) getMaterialAnimationVector2(data, ref translate); break;
case RenderBase.OMaterialAnimationType.translateCoordinator2: if (s == 2) getMaterialAnimationVector2(data, ref translate); break;
case RenderBase.OMaterialAnimationType.scaleCoordinator0: if (s == 0) getMaterialAnimationVector2(data, ref scaling); break; //Scaling
case RenderBase.OMaterialAnimationType.scaleCoordinator1: if (s == 1) getMaterialAnimationVector2(data, ref scaling); break;
case RenderBase.OMaterialAnimationType.scaleCoordinator2: if (s == 2) getMaterialAnimationVector2(data, ref scaling); break;
case RenderBase.OMaterialAnimationType.rotateCoordinator0: if (s == 0) getMaterialAnimationFloat(data, ref rotate); break; //Rotation
case RenderBase.OMaterialAnimationType.rotateCoordinator1: if (s == 1) getMaterialAnimationFloat(data, ref rotate); break;
case RenderBase.OMaterialAnimationType.rotateCoordinator2: if (s == 2) getMaterialAnimationFloat(data, ref rotate); break;
}
}
}
}
#endregion
if (fragmentShaderMode)
{
fragmentShader.SetValue(string.Format("uvTranslate[{0}]", s), new Vector4(-translate.X, -translate.Y, 0, 0));
fragmentShader.SetValue(string.Format("uvScale[{0}]", s), new Vector4(scaling.X, scaling.Y, 0, 0));
fragmentShader.SetValue(string.Format("uvTransform[{0}]", s), Matrix.RotationZ(rotate));
}
else
{
device.SetTextureStageState(s, TextureStageStates.TextureTransform, (int)TextureTransform.Count2);
Matrix uvTransform = rotateCenter2D(rotate) * Matrix.Scaling(scaling.X, scaling.Y, 1) * translate2D(-translate);
if (s == legacyTextureUnit) device.Transform.Texture0 = uvTransform;
}
device.SetSamplerState(s, SamplerStageStates.MinFilter, (int)TextureFilter.Linear);
switch (material.textureMapper[s].magFilter)
{
case RenderBase.OTextureMagFilter.nearest: device.SetSamplerState(s, SamplerStageStates.MagFilter, (int)TextureFilter.None); break;
case RenderBase.OTextureMagFilter.linear: device.SetSamplerState(s, SamplerStageStates.MagFilter, (int)TextureFilter.Linear); break;
}
//Addressing
device.SetSamplerState(s, SamplerStageStates.BorderColor, borderColor[s].ToArgb());
switch (material.textureMapper[s].wrapU)
{
case RenderBase.OTextureWrap.repeat: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Wrap); break;
case RenderBase.OTextureWrap.mirroredRepeat: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Mirror); break;
case RenderBase.OTextureWrap.clampToEdge: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Clamp); break;
case RenderBase.OTextureWrap.clampToBorder: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Border); break;
}
switch (material.textureMapper[s].wrapV)
{
case RenderBase.OTextureWrap.repeat: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Wrap); break;
case RenderBase.OTextureWrap.mirroredRepeat: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Mirror); break;
case RenderBase.OTextureWrap.clampToEdge: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Clamp); break;
case RenderBase.OTextureWrap.clampToBorder: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Border); break;
}
}
#endregion
#region "Culling/Alpha/Depth/Stencil testing/blending stuff Setup"
//Culling
switch (material.rasterization.cullMode)
{
case RenderBase.OCullMode.backFace: device.RenderState.CullMode = Cull.Clockwise; break;
case RenderBase.OCullMode.frontFace: device.RenderState.CullMode = Cull.CounterClockwise; break;
case RenderBase.OCullMode.never: device.RenderState.CullMode = Cull.None; break;
}
//Alpha testing
RenderBase.OAlphaTest alpha = material.fragmentShader.alphaTest;
device.RenderState.AlphaTestEnable = alpha.isTestEnabled;
device.RenderState.AlphaFunction = getCompare(alpha.testFunction);
device.RenderState.ReferenceAlpha = (int)alpha.testReference;
//Depth testing
RenderBase.ODepthOperation depth = material.fragmentOperation.depth;
device.RenderState.ZBufferEnable = depth.isTestEnabled;
device.RenderState.ZBufferFunction = getCompare(depth.testFunction);
device.RenderState.ZBufferWriteEnable = depth.isMaskEnabled;
//Alpha blending
RenderBase.OBlendOperation blend = material.fragmentOperation.blend;
device.RenderState.AlphaBlendEnable = blend.mode == RenderBase.OBlendMode.blend;
device.RenderState.SeparateAlphaBlendEnabled = true;
device.RenderState.SourceBlend = getBlend(blend.rgbFunctionSource);
device.RenderState.DestinationBlend = getBlend(blend.rgbFunctionDestination);
device.RenderState.BlendOperation = getBlendOperation(blend.rgbBlendEquation);
device.RenderState.AlphaSourceBlend = getBlend(blend.alphaFunctionSource);
device.RenderState.AlphaDestinationBlend = getBlend(blend.alphaFunctionDestination);
device.RenderState.AlphaBlendOperation = getBlendOperation(blend.alphaBlendEquation);
device.RenderState.BlendFactorColor = blendColor.ToArgb();
//Stencil testing
RenderBase.OStencilOperation stencil = material.fragmentOperation.stencil;
device.RenderState.StencilEnable = stencil.isTestEnabled;
device.RenderState.StencilFunction = getCompare(stencil.testFunction);
device.RenderState.ReferenceStencil = (int)stencil.testReference;
device.RenderState.StencilWriteMask = (int)stencil.testMask;
device.RenderState.StencilFail = getStencilOperation(stencil.failOperation);
device.RenderState.StencilZBufferFail = getStencilOperation(stencil.zFailOperation);
device.RenderState.StencilPass = getStencilOperation(stencil.passOperation);
#endregion
#region "Rendering"
//Vertex rendering
VertexFormats vertexFormat = VertexFormats.Position | VertexFormats.Normal | VertexFormats.Texture3 | VertexFormats.Diffuse;
device.VertexFormat = vertexFormat;
if (fragmentShaderMode) fragmentShader.BeginPass(0);
if (meshes[objectIndex].Length > 0)
{
customVertex[] buffer = meshes[objectIndex];
if (ctrlSA.animate)
{
buffer = new customVertex[meshes[objectIndex].Length];
for (int vertex = 0; vertex < buffer.Length; vertex++)
{
buffer[vertex] = meshes[objectIndex][vertex];
RenderBase.OVertex input = obj.vertices[vertex];
Vector3 position = new Vector3(input.position.x, input.position.y, input.position.z);
Vector4 p = new Vector4();
int weightIndex = 0;
float weightSum = 0;
foreach (int boneIndex in input.node)
{
float weight = 0;
if (weightIndex < input.weight.Count) weight = input.weight[weightIndex++];
weightSum += weight;
p += Vector3.Transform(position, animationSkeletonTransform[boneIndex]) * weight;
}
if (weightSum < 1) p += new Vector4(position.X, position.Y, position.Z, 0) * (1 - weightSum);
buffer[vertex].x = p.X;
buffer[vertex].y = p.Y;
buffer[vertex].z = p.Z;
}
}
using (VertexBuffer vertexBuffer = new VertexBuffer(typeof(customVertex), buffer.Length, device, Usage.None, vertexFormat, Pool.Managed))
{
vertexBuffer.SetData(buffer, 0, LockFlags.None);
device.SetStreamSource(0, vertexBuffer, 0);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, buffer.Length / 3);
}
}
if (fragmentShaderMode) fragmentShader.EndPass();
#endregion
}
}
if (fragmentShaderMode) fragmentShader.End();
//HUD
if (cfgShowInformation && currentModel > -1)
{
resetRenderState();
RenderBase.OModel mdl = models.model[currentModel];
StringBuilder info = new StringBuilder();
info.AppendLine("Meshes: " + mdl.mesh.Count);
info.AppendLine("Triangles: " + (models.model[currentModel].verticesCount / 3));
info.AppendLine("Bones: " + mdl.skeleton.Count);
info.AppendLine("Materials: " + mdl.material.Count);
info.AppendLine("Textures: " + models.texture.Count);
if (ctrlSA.CurrentAnimation > -1) info.AppendLine("S. Frame: " + ctrlSA.CurrentFrameInfo);
if (ctrlMA.CurrentAnimation > -1) info.AppendLine("M. Frame: " + ctrlMA.CurrentFrameInfo);
if (ctrlVA.CurrentAnimation > -1) info.AppendLine("V. Frame: " + ctrlVA.CurrentFrameInfo);
drawText(info.ToString(), 256, 192);
}
device.EndScene();
device.Present();
ctrlSA.advanceFrame();
ctrlMA.advanceFrame();
ctrlVA.advanceFrame();
}
/// <summary>
/// Creates a new Bone.
/// </summary>
public OAnimationBone()
{
translation = new RenderBase.OVector3();
rotationQuaternion = new Quaternion();
scale = new RenderBase.OVector3();
}
public void render()
{
//Compile the Fragment Shader
if (!useLegacyTexturing)
{
string compilationErros;
fragmentShader = Effect.FromString(device, Properties.Resources.OFragmentShader, null, null, ShaderFlags.SkipOptimization, null, out compilationErros);
if (compilationErros != "") MessageBox.Show("Failed to compile Fragment Shader!" + Environment.NewLine + compilationErros, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
fragmentShader.Technique = "Combiner";
}
RenderBase.OVector3 minVector = new RenderBase.OVector3();
RenderBase.OVector3 maxVector = new RenderBase.OVector3();
if (model.model.Count > 0) currentModel = 0;
updateTextures();
#region "Grid buffer creation"
CustomVertex.PositionColored[] gridBuffer = new CustomVertex.PositionColored[218];
int bufferIndex = 0;
for (int i = -50; i <= 50; i += 2)
{
if (i == 0)
{
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(-50f, 0, i, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(0, 0, i, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(5f, 0, i, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(50f, 0, i, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, -50f, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, -5f, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, 0, Color.White.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, 50f, Color.White.ToArgb());
}
else
{
int lColor;
if ((i % 10) == 0)
lColor = Color.White.ToArgb();
else
lColor = Color.DarkGray.ToArgb();
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(-50f, 0, i, lColor);
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(50f, 0, i, lColor);
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, -50f, lColor);
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(i, 0, 50f, lColor);
}
}
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(0, 0, 0, Color.Red.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(5f, 0, 0, Color.Red.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(0, 0, 0, Color.Green.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(0, 5f, 0, Color.Green.ToArgb());
gridBuffer[bufferIndex++] = new CustomVertex.PositionColored(0, 0, 0, Color.Blue.ToArgb());
gridBuffer[bufferIndex] = new CustomVertex.PositionColored(0, 0, -5f, Color.Blue.ToArgb());
#endregion
keepRendering = true;
while (keepRendering)
{
device.Clear(ClearFlags.Stencil | ClearFlags.Target | ClearFlags.ZBuffer, bgColor, 1.0f, 15);
device.SetTexture(0, null);
device.BeginScene();
device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, (float)pParams.BackBufferWidth / pParams.BackBufferHeight, 0.01f, 1000.0f);
device.Transform.View = Matrix.LookAtLH(new Vector3(0.0f, 0.0f, 20.0f), new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f));
//View
if (currentModel > -1)
{
minVector = model.model[currentModel].minVector;
maxVector = model.model[currentModel].maxVector;
}
float minSize = Math.Min(Math.Min(minVector.x, minVector.y), minVector.z);
float maxSize = Math.Max(Math.Max(maxVector.x, maxVector.y), maxVector.z);
float scale = (10f / (maxSize - minSize)); //Try to adjust to screen
if (maxSize - minSize == 0) scale = 1;
Matrix centerMatrix = Matrix.Translation(
-(minVector.x + maxVector.x) / 2,
-(minVector.y + maxVector.y) / 2,
-(minVector.z + maxVector.z) / 2);
Matrix translationMatrix = Matrix.Translation(
(-translation.X / 50) / scale,
(translation.Y / 50) / scale,
zoom / scale);
Matrix baseTransform = Matrix.Identity;
baseTransform *= Matrix.RotationY(rotation.Y) * Matrix.RotationX(rotation.X);
baseTransform *= centerMatrix * translationMatrix * Matrix.Scaling(-scale, scale, scale);
//Grid
if (showGrid)
{
resetRenderState();
device.Transform.World = baseTransform;
device.VertexFormat = CustomVertex.PositionColored.Format;
VertexBuffer lineBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), gridBuffer.Length, device, Usage.None, CustomVertex.PositionColored.Format, Pool.Managed);
lineBuffer.SetData(gridBuffer, 0, LockFlags.None);
device.SetStreamSource(0, lineBuffer, 0);
device.DrawPrimitives(PrimitiveType.LineList, 0, gridBuffer.Length / 2);
lineBuffer.Dispose();
}
if (!useLegacyTexturing)
{
fragmentShader.Begin(0);
#region "Shader Setup"
fragmentShader.SetValue("world", device.Transform.World);
fragmentShader.SetValue("view", device.Transform.View);
fragmentShader.SetValue("projection", device.Transform.Projection);
fragmentShader.SetValue("lights[0].pos", new Vector4(0, -10, -10, 0));
fragmentShader.SetValue("lights[0].ambient", new Vector4(0.1f, 0.1f, 0.1f, 1));
fragmentShader.SetValue("lights[0].diffuse", new Vector4(1, 1, 1, 1));
fragmentShader.SetValue("lights[0].specular", new Vector4(1, 1, 1, 1));
fragmentShader.SetValue("numLights", 1);
#endregion
}
if (wireframeMode)
device.RenderState.FillMode = FillMode.WireFrame;
else
device.RenderState.FillMode = FillMode.Solid;
if (currentModel > -1)
{
RenderBase.OModel mdl = model.model[currentModel];
device.Transform.World = getMatrix(mdl.transform) * baseTransform;
#region "Skeletal Animation"
Matrix[] animationSkeletonTransform = new Matrix[mdl.skeleton.Count];
if (ctrlSA.animate)
{
Matrix[] skeletonTransform = new Matrix[mdl.skeleton.Count];
for (int index = 0; index < mdl.skeleton.Count; index++)
{
skeletonTransform[index] = Matrix.Identity;
transformSkeleton(mdl.skeleton, index, ref skeletonTransform[index]);
}
List<RenderBase.OSkeletalAnimationBone> bone = ((RenderBase.OSkeletalAnimation)model.skeletalAnimation.list[ctrlSA.CurrentAnimation]).bone;
List<OAnimationBone> frameAnimationSkeleton = new List<OAnimationBone>();
for (int index = 0; index < mdl.skeleton.Count; index++)
{
OAnimationBone newBone = new OAnimationBone();
newBone.parentId = mdl.skeleton[index].parentId;
newBone.rotationQuaternion = getQuaternion(mdl.skeleton[index].rotation);
newBone.translation = new RenderBase.OVector3(mdl.skeleton[index].translation);
foreach (RenderBase.OSkeletalAnimationBone b in bone)
{
if (b.name == mdl.skeleton[index].name)
{
if (b.isFullBakedFormat)
{
newBone.hasTransform = true;
newBone.transform = b.transform[(int)ctrlSA.Frame % b.transform.Count];
}
else if (b.isFrameFormat)
{
float fa = (float)Math.Floor(ctrlSA.Frame);
float fb = (float)Math.Ceiling(ctrlSA.Frame);
if (b.rotationQuaternion.exists)
{
int aIndex = Math.Min((int)fa, b.rotationQuaternion.vector.Count - 1);
int bIndex = Math.Min((int)fb, b.rotationQuaternion.vector.Count - 1);
Quaternion q1 = getQuaternion(b.rotationQuaternion.vector[aIndex]);
Quaternion q2 = getQuaternion(b.rotationQuaternion.vector[bIndex]);
newBone.rotationQuaternion = Quaternion.Slerp(q1, q2, ctrlSA.Frame - fa);
}
if (b.translation.exists)
{
int aIndex = Math.Min((int)fa, b.translation.vector.Count - 1);
int bIndex = Math.Min((int)fb, b.translation.vector.Count - 1);
RenderBase.OVector4 t1 = b.translation.vector[aIndex];
RenderBase.OVector4 t2 = b.translation.vector[bIndex];
RenderBase.OVector4 t = AnimationUtils.interpolateLinear(t1, t2, ctrlSA.Frame - fa);
newBone.translation = new RenderBase.OVector3(t.x, t.y, t.z);
newBone.translation.x *= mdl.skeleton[index].absoluteScale.x;
newBone.translation.y *= mdl.skeleton[index].absoluteScale.y;
newBone.translation.z *= mdl.skeleton[index].absoluteScale.z;
}
}
else
{
/*
* Rotation
*/
float fa = (float)Math.Floor(ctrlSA.Frame);
float fb = (float)Math.Ceiling(ctrlSA.Frame);
float x1, x2, y1, y2, z1, z2;
x1 = x2 = mdl.skeleton[index].rotation.x;
y1 = y2 = mdl.skeleton[index].rotation.y;
z1 = z2 = mdl.skeleton[index].rotation.z;
if (b.rotationX.exists) x1 = AnimationUtils.getKey(b.rotationX, fa);
if (b.rotationY.exists) y1 = AnimationUtils.getKey(b.rotationY, fa);
if (b.rotationZ.exists) z1 = AnimationUtils.getKey(b.rotationZ, fa);
if (b.rotationX.exists) x2 = AnimationUtils.getKey(b.rotationX, fb);
if (b.rotationY.exists) y2 = AnimationUtils.getKey(b.rotationY, fb);
if (b.rotationZ.exists) z2 = AnimationUtils.getKey(b.rotationZ, fb);
Quaternion q1 = getQuaternion(new RenderBase.OVector3(x1, y1, z1));
Quaternion q2 = getQuaternion(new RenderBase.OVector3(x2, y2, z2));
newBone.rotationQuaternion = Quaternion.Slerp(q1, q2, ctrlSA.Frame - fa);
/*
* Translation
*/
if (b.translationX.exists)
{
newBone.translation.x = AnimationUtils.getKey(b.translationX, ctrlSA.Frame);
newBone.translation.x *= mdl.skeleton[index].absoluteScale.x;
}
if (b.translationY.exists)
{
newBone.translation.y = AnimationUtils.getKey(b.translationY, ctrlSA.Frame);
newBone.translation.y *= mdl.skeleton[index].absoluteScale.y;
}
if (b.translationZ.exists)
{
newBone.translation.z = AnimationUtils.getKey(b.translationZ, ctrlSA.Frame);
newBone.translation.z *= mdl.skeleton[index].absoluteScale.z;
}
}
break;
}
}
frameAnimationSkeleton.Add(newBone);
}
for (int index = 0; index < mdl.skeleton.Count; index++)
{
animationSkeletonTransform[index] = Matrix.Identity;
if (frameAnimationSkeleton[index].hasTransform)
animationSkeletonTransform[index] = getMatrix(frameAnimationSkeleton[index].transform);
else
transformAnimationSkeleton(frameAnimationSkeleton, index, ref animationSkeletonTransform[index]);
animationSkeletonTransform[index] = Matrix.Invert(skeletonTransform[index]) * animationSkeletonTransform[index];
}
}
#endregion
int objectIndex = 0;
foreach (RenderBase.OMesh obj in mdl.mesh)
{
bool isVisible = obj.isVisible;
if (ctrlVA.animate)
{
foreach (RenderBase.OVisibilityAnimationData data in ((RenderBase.OVisibilityAnimation)model.visibilityAnimation.list[ctrlVA.CurrentAnimation]).data)
{
RenderBase.OAnimationKeyFrame frame = AnimationUtils.getSmallerPoint(data.visibilityList.keyFrames, ctrlVA.Frame);
if (data.name == obj.name) isVisible = frame.bValue;
}
}
if (isVisible)
{
RenderBase.OMaterial material = mdl.material[obj.materialId];
#region "Material Animation"
int[] textureId = { -1, -1, -1 };
Color blendColor = material.fragmentOperation.blend.blendColor;
Color[] borderColor = new Color[3];
borderColor[0] = material.textureMapper[0].borderColor;
borderColor[1] = material.textureMapper[1].borderColor;
borderColor[2] = material.textureMapper[2].borderColor;
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)model.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.textureMapper0: getMaterialAnimationInt(data, ref textureId[0]); break;
case RenderBase.OMaterialAnimationType.textureMapper1: getMaterialAnimationInt(data, ref textureId[1]); break;
case RenderBase.OMaterialAnimationType.textureMapper2: getMaterialAnimationInt(data, ref textureId[2]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper0: getMaterialAnimationColor(data, ref borderColor[0]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper1: getMaterialAnimationColor(data, ref borderColor[1]); break;
case RenderBase.OMaterialAnimationType.borderColorMapper2: getMaterialAnimationColor(data, ref borderColor[2]); break;
case RenderBase.OMaterialAnimationType.blendColor: getMaterialAnimationColor(data, ref blendColor); break;
}
}
}
}
#endregion
int legacyTexture = -1;
if (!useLegacyTexturing)
{
#region "Shader combiner parameters"
RenderBase.OMaterialColor materialColor = new RenderBase.OMaterialColor();
materialColor = material.materialColor;
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)model.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.constant0: getMaterialAnimationColor(data, ref materialColor.constant0); break;
case RenderBase.OMaterialAnimationType.constant1: getMaterialAnimationColor(data, ref materialColor.constant1); break;
case RenderBase.OMaterialAnimationType.constant2: getMaterialAnimationColor(data, ref materialColor.constant2); break;
case RenderBase.OMaterialAnimationType.constant3: getMaterialAnimationColor(data, ref materialColor.constant3); break;
case RenderBase.OMaterialAnimationType.constant4: getMaterialAnimationColor(data, ref materialColor.constant4); break;
case RenderBase.OMaterialAnimationType.constant5: getMaterialAnimationColor(data, ref materialColor.constant5); break;
case RenderBase.OMaterialAnimationType.diffuse: getMaterialAnimationColor(data, ref materialColor.diffuse); break;
case RenderBase.OMaterialAnimationType.specular0: getMaterialAnimationColor(data, ref materialColor.specular0); break;
case RenderBase.OMaterialAnimationType.specular1: getMaterialAnimationColor(data, ref materialColor.specular1); ; break;
case RenderBase.OMaterialAnimationType.ambient: getMaterialAnimationColor(data, ref materialColor.ambient); break;
}
}
}
}
fragmentShader.SetValue("hasTextures", textures.Count > 0);
fragmentShader.SetValue("uvCount", obj.texUVCount);
fragmentShader.SetValue("isD0Enabled", material.fragmentShader.lighting.isDistribution0Enabled);
fragmentShader.SetValue("isD1Enabled", material.fragmentShader.lighting.isDistribution1Enabled);
fragmentShader.SetValue("isG0Enabled", material.fragmentShader.lighting.isGeometryFactor0Enabled);
fragmentShader.SetValue("isG1Enabled", material.fragmentShader.lighting.isGeometryFactor1Enabled);
fragmentShader.SetValue("isREnabled", material.fragmentShader.lighting.isReflectionEnabled);
fragmentShader.SetValue("bumpIndex", (int)material.fragmentShader.bump.texture);
fragmentShader.SetValue("bumpMode", (int)material.fragmentShader.bump.mode);
fragmentShader.SetValue("mEmissive", getColor(materialColor.emission));
fragmentShader.SetValue("mAmbient", getColor(materialColor.ambient));
fragmentShader.SetValue("mDiffuse", getColor(materialColor.diffuse));
fragmentShader.SetValue("mSpecular", getColor(materialColor.specular0));
fragmentShader.SetValue("hasNormal", obj.hasNormal);
for (int i = 0; i < 6; i++)
{
RenderBase.OTextureCombiner textureCombiner = material.fragmentShader.textureCombiner[i];
fragmentShader.SetValue(String.Format("combiners[{0}].colorCombine", i), (int)textureCombiner.combineRgb);
fragmentShader.SetValue(String.Format("combiners[{0}].alphaCombine", i), (int)textureCombiner.combineAlpha);
fragmentShader.SetValue(String.Format("combiners[{0}].colorScale", i), (float)textureCombiner.rgbScale);
fragmentShader.SetValue(String.Format("combiners[{0}].alphaScale", i), (float)textureCombiner.alphaScale);
for (int j = 0; j < 3; j++)
{
fragmentShader.SetValue(String.Format("combiners[{0}].colorArg[{1}]", i, j), (int)textureCombiner.rgbSource[j]);
fragmentShader.SetValue(String.Format("combiners[{0}].colorOp[{1}]", i, j), (int)textureCombiner.rgbOperand[j]);
fragmentShader.SetValue(String.Format("combiners[{0}].alphaArg[{1}]", i, j), (int)textureCombiner.alphaSource[j]);
fragmentShader.SetValue(String.Format("combiners[{0}].alphaOp[{1}]", i, j), (int)textureCombiner.alphaOperand[j]);
}
Color constantColor = Color.White;
switch (textureCombiner.constantColor)
{
case RenderBase.OConstantColor.ambient: constantColor = materialColor.ambient; break;
case RenderBase.OConstantColor.constant0: constantColor = materialColor.constant0; break;
case RenderBase.OConstantColor.constant1: constantColor = materialColor.constant1; break;
case RenderBase.OConstantColor.constant2: constantColor = materialColor.constant2; break;
case RenderBase.OConstantColor.constant3: constantColor = materialColor.constant3; break;
case RenderBase.OConstantColor.constant4: constantColor = materialColor.constant4; break;
case RenderBase.OConstantColor.constant5: constantColor = materialColor.constant5; break;
case RenderBase.OConstantColor.diffuse: constantColor = materialColor.diffuse; break;
case RenderBase.OConstantColor.emission: constantColor = materialColor.emission; break;
case RenderBase.OConstantColor.specular0: constantColor = materialColor.specular0; break;
case RenderBase.OConstantColor.specular1: constantColor = materialColor.specular1; break;
}
fragmentShader.SetValue(String.Format("combiners[{0}].constant", i), new Vector4(
(float)constantColor.R / 0xff,
(float)constantColor.G / 0xff,
(float)constantColor.B / 0xff,
(float)constantColor.A / 0xff));
}
if (ctrlMA.animate)
{
RenderBase.OMaterialAnimation materialAnimation = (RenderBase.OMaterialAnimation)model.materialAnimation.list[ctrlMA.CurrentAnimation];
foreach (CustomTexture texture in textures)
{
if (texture.name == (textureId[0] > -1 ? materialAnimation.textureName[textureId[0]] : material.name0)) fragmentShader.SetValue("texture0", texture.texture);
else if (texture.name == (textureId[1] > -1 ? materialAnimation.textureName[textureId[1]] : material.name1)) fragmentShader.SetValue("texture1", texture.texture);
else if (texture.name == (textureId[2] > -1 ? materialAnimation.textureName[textureId[2]] : material.name2)) fragmentShader.SetValue("texture2", texture.texture);
}
}
else
{
foreach (CustomTexture texture in textures)
{
if (texture.name == material.name0) fragmentShader.SetValue("texture0", texture.texture);
else if (texture.name == material.name1) fragmentShader.SetValue("texture1", texture.texture);
else if (texture.name == material.name2) fragmentShader.SetValue("texture2", texture.texture);
}
}
#endregion
}
else
{
string[] name = new string[3];
name[0] = material.name0;
name[1] = material.name1;
name[2] = material.name2;
if (ctrlMA.animate)
{
RenderBase.OMaterialAnimation materialAnimation = (RenderBase.OMaterialAnimation)model.materialAnimation.list[ctrlMA.CurrentAnimation];
for (int i = 0; i < 3; i++) if (textureId[i] > -1) name[i] = materialAnimation.textureName[textureId[i]];
}
int nCount = int.MaxValue;
int maxPixelCount = 0;
for (int i = 0; i < textures.Count; i++)
{
for (int j = 0; j < 3; j++)
{
if (textures[i].name == name[j])
{
//Strings with more "n" on the names are most likely to be Normal Maps, and we don't want those.
int n = textures[i].name.Length - textures[i].name.ToLower().Replace("n", "").Length;
int pixelCount = textures[i].width * textures[i].height; //Bigger textures are more likely to contain relevant stuff
if (n <= nCount && pixelCount >= maxPixelCount)
{
legacyTexture = i;
nCount = n;
maxPixelCount = pixelCount;
}
}
}
}
if (legacyTexture > -1)
device.SetTexture(0, textures[legacyTexture].texture);
else
device.SetTexture(0, null);
}
#region "Texture Filtering/Addressing Setup"
//Filtering
for (int s = 0; s < 3; s++)
{
RenderBase.OTextureCoordinator coordinator = material.textureCoordinator[s];
Vector2 translate = new Vector2(coordinator.translateU, coordinator.translateV);
Vector2 scaling = new Vector2(coordinator.scaleU, coordinator.scaleV);
if (scaling == Vector2.Empty) scaling = new Vector2(1, 1);
float rotate = coordinator.rotate;
#region "Material Animation"
if (ctrlMA.animate)
{
foreach (RenderBase.OMaterialAnimationData data in ((RenderBase.OMaterialAnimation)model.materialAnimation.list[ctrlMA.CurrentAnimation]).data)
{
if (data.name == material.name)
{
switch (data.type)
{
case RenderBase.OMaterialAnimationType.translateCoordinator0: if (s == 0) getMaterialAnimationVector2(data, ref translate); break; //Translation
case RenderBase.OMaterialAnimationType.translateCoordinator1: if (s == 1) getMaterialAnimationVector2(data, ref translate); break;
case RenderBase.OMaterialAnimationType.translateCoordinator2: if (s == 2) getMaterialAnimationVector2(data, ref translate); break;
case RenderBase.OMaterialAnimationType.scaleCoordinator0: if (s == 0) getMaterialAnimationVector2(data, ref scaling); break; //Scaling
case RenderBase.OMaterialAnimationType.scaleCoordinator1: if (s == 1) getMaterialAnimationVector2(data, ref scaling); break;
case RenderBase.OMaterialAnimationType.scaleCoordinator2: if (s == 2) getMaterialAnimationVector2(data, ref scaling); break;
case RenderBase.OMaterialAnimationType.rotateCoordinator0: if (s == 0) getMaterialAnimationFloat(data, ref rotate); break; //Rotation
case RenderBase.OMaterialAnimationType.rotateCoordinator1: if (s == 1) getMaterialAnimationFloat(data, ref rotate); break;
case RenderBase.OMaterialAnimationType.rotateCoordinator2: if (s == 2) getMaterialAnimationFloat(data, ref rotate); break;
}
}
}
}
#endregion
translate.X = -translate.X; //For some reason UVs need to be flipped to show up correct on animation
translate.Y = -translate.Y;
Matrix uvTransform = rotateCenter2D(rotate) * Matrix.Scaling(scaling.X, scaling.Y, 1) * translate2D(translate);
if (!useLegacyTexturing)
{
fragmentShader.SetValue(String.Format("uvTranslate[{0}]", s), new Vector4(translate.X, translate.Y, 0, 0));
fragmentShader.SetValue(String.Format("uvScale[{0}]", s), new Vector4(scaling.X, scaling.Y, 0, 0));
fragmentShader.SetValue(String.Format("uvTransform[{0}]", s), Matrix.RotationZ(rotate));
}
else
{
device.SetTextureStageState(s, TextureStageStates.TextureTransform, (int)TextureTransform.Count2);
if (s == legacyTexture) device.Transform.Texture0 = uvTransform;
}
device.SetSamplerState(s, SamplerStageStates.MinFilter, (int)TextureFilter.Linear);
switch (material.textureMapper[s].magFilter)
{
case RenderBase.OTextureMagFilter.nearest: device.SetSamplerState(s, SamplerStageStates.MagFilter, (int)TextureFilter.None); break;
case RenderBase.OTextureMagFilter.linear: device.SetSamplerState(s, SamplerStageStates.MagFilter, (int)TextureFilter.Linear); break;
}
//Addressing
device.SetSamplerState(s, SamplerStageStates.BorderColor, borderColor[s].ToArgb());
switch (material.textureMapper[s].wrapU)
{
case RenderBase.OTextureWrap.repeat: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Wrap); break;
case RenderBase.OTextureWrap.mirroredRepeat: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Mirror); break;
case RenderBase.OTextureWrap.clampToEdge: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Clamp); break;
case RenderBase.OTextureWrap.clampToBorder: device.SetSamplerState(s, SamplerStageStates.AddressU, (int)TextureAddress.Border); break;
}
switch (material.textureMapper[s].wrapV)
{
case RenderBase.OTextureWrap.repeat: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Wrap); break;
case RenderBase.OTextureWrap.mirroredRepeat: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Mirror); break;
case RenderBase.OTextureWrap.clampToEdge: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Clamp); break;
case RenderBase.OTextureWrap.clampToBorder: device.SetSamplerState(s, SamplerStageStates.AddressV, (int)TextureAddress.Border); break;
}
}
#endregion
#region "Culling/Alpha/Depth/Stencil testing/blending stuff Setup"
//Culling
switch (material.rasterization.cullMode)
{
case RenderBase.OCullMode.backFace: device.RenderState.CullMode = Cull.Clockwise; break;
case RenderBase.OCullMode.frontFace: device.RenderState.CullMode = Cull.CounterClockwise; break;
case RenderBase.OCullMode.never: device.RenderState.CullMode = Cull.None; break;
}
//Alpha testing
RenderBase.OAlphaTest alpha = material.fragmentShader.alphaTest;
device.RenderState.AlphaTestEnable = alpha.isTestEnabled;
device.RenderState.AlphaFunction = getCompare(alpha.testFunction);
device.RenderState.ReferenceAlpha = (int)alpha.testReference;
//Depth testing
RenderBase.ODepthOperation depth = material.fragmentOperation.depth;
device.RenderState.ZBufferEnable = depth.isTestEnabled;
device.RenderState.ZBufferFunction = getCompare(depth.testFunction);
device.RenderState.ZBufferWriteEnable = depth.isMaskEnabled;
//Alpha blending
RenderBase.OBlendOperation blend = material.fragmentOperation.blend;
device.RenderState.AlphaBlendEnable = blend.mode == RenderBase.OBlendMode.blend;
device.RenderState.SeparateAlphaBlendEnabled = true;
device.RenderState.SourceBlend = getBlend(blend.rgbFunctionSource);
device.RenderState.DestinationBlend = getBlend(blend.rgbFunctionDestination);
device.RenderState.BlendOperation = getBlendOperation(blend.rgbBlendEquation);
device.RenderState.AlphaSourceBlend = getBlend(blend.alphaFunctionSource);
device.RenderState.AlphaDestinationBlend = getBlend(blend.alphaFunctionDestination);
device.RenderState.AlphaBlendOperation = getBlendOperation(blend.alphaBlendEquation);
device.RenderState.BlendFactorColor = blendColor.ToArgb();
//Stencil testing
RenderBase.OStencilOperation stencil = material.fragmentOperation.stencil;
device.RenderState.StencilEnable = stencil.isTestEnabled;
device.RenderState.StencilFunction = getCompare(stencil.testFunction);
device.RenderState.ReferenceStencil = (int)stencil.testReference;
device.RenderState.StencilWriteMask = (int)stencil.testMask;
device.RenderState.StencilFail = getStencilOperation(stencil.failOperation);
device.RenderState.StencilZBufferFail = getStencilOperation(stencil.zFailOperation);
device.RenderState.StencilPass = getStencilOperation(stencil.passOperation);
#endregion
#region "Rendering"
//Vertex rendering
VertexFormats vertexFormat = VertexFormats.Position | VertexFormats.Normal | VertexFormats.Texture3 | VertexFormats.Diffuse;
device.VertexFormat = vertexFormat;
VertexBuffer vertexBuffer;
if (!useLegacyTexturing) fragmentShader.BeginPass(0);
if (obj.renderBuffer.Length > 0)
{
if (ctrlSA.animate)
{
RenderBase.CustomVertex[] buffer = new RenderBase.CustomVertex[obj.renderBuffer.Length];
for (int vertex = 0; vertex < obj.renderBuffer.Length; vertex++)
{
buffer[vertex] = obj.renderBuffer[vertex];
RenderBase.OVertex input = obj.vertices[vertex];
Vector3 position = new Vector3(input.position.x, input.position.y, input.position.z);
Vector4 p = new Vector4();
int weightIndex = 0;
float weightSum = 0;
foreach (int boneIndex in input.node)
{
float weight = 0;
if (weightIndex < input.weight.Count) weight = input.weight[weightIndex++];
weightSum += weight;
p += Vector3.Transform(position, animationSkeletonTransform[boneIndex]) * weight;
}
if (weightSum < 1) p += new Vector4(position.X, position.Y, position.Z, 0) * (1 - weightSum);
buffer[vertex].x = p.X;
buffer[vertex].y = p.Y;
buffer[vertex].z = p.Z;
}
vertexBuffer = new VertexBuffer(typeof(RenderBase.CustomVertex), buffer.Length, device, Usage.None, vertexFormat, Pool.Managed);
vertexBuffer.SetData(buffer, 0, LockFlags.None);
device.SetStreamSource(0, vertexBuffer, 0);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, buffer.Length / 3);
}
else
{
vertexBuffer = new VertexBuffer(typeof(RenderBase.CustomVertex), obj.renderBuffer.Length, device, Usage.None, vertexFormat, Pool.Managed);
vertexBuffer.SetData(obj.renderBuffer, 0, LockFlags.None);
device.SetStreamSource(0, vertexBuffer, 0);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, obj.renderBuffer.Length / 3);
}
vertexBuffer.Dispose();
}
if (!useLegacyTexturing) fragmentShader.EndPass();
#endregion
objectIndex++;
}
}
}
if (!useLegacyTexturing) fragmentShader.End();
//HUD
if (showHUD && currentModel > -1)
{
resetRenderState();
RenderBase.OModel mdl = model.model[currentModel];
StringBuilder info = new StringBuilder();
info.AppendLine("Meshes: " + model.model[currentModel].mesh.Count);
info.AppendLine("Triangles: " + (model.model[currentModel].verticesCount / 3));
info.AppendLine("Bones: " + mdl.skeleton.Count);
info.AppendLine("Materials: " + mdl.material.Count);
info.AppendLine("Textures: " + model.texture.Count);
if (ctrlSA.CurrentAnimation > -1) info.AppendLine("S. Frame: " + ctrlSA.Frame + " / " + model.skeletalAnimation.list[ctrlSA.CurrentAnimation].frameSize.ToString());
if (ctrlMA.CurrentAnimation > -1) info.AppendLine("M. Frame: " + ctrlMA.Frame + " / " + model.materialAnimation.list[ctrlMA.CurrentAnimation].frameSize.ToString());
if (ctrlVA.CurrentAnimation > -1) info.AppendLine("V. Frame: " + ctrlVA.Frame + " / " + model.visibilityAnimation.list[ctrlVA.CurrentAnimation].frameSize.ToString());
drawText(info.ToString(), 256, 192);
}
device.EndScene();
device.Present();
if (ctrlSA.animate) ctrlSA.advanceFrame(model.skeletalAnimation.list[ctrlSA.CurrentAnimation].frameSize);
if (ctrlMA.animate) ctrlMA.advanceFrame(model.materialAnimation.list[ctrlMA.CurrentAnimation].frameSize);
if (ctrlVA.animate) ctrlVA.advanceFrame(model.visibilityAnimation.list[ctrlVA.CurrentAnimation].frameSize);
Application.DoEvents();
}
}
/// <summary>
/// Imports a Wavefront OBJ model from file.
/// </summary>
/// <param name="fileName">The complete file name</param>
/// <returns></returns>
public static RenderBase.OModelGroup import(string fileName)
{
RenderBase.OModelGroup output = new RenderBase.OModelGroup();
RenderBase.OModel model = new RenderBase.OModel();
string obj = File.ReadAllText(fileName);
List<RenderBase.OVector3> vertices = new List<RenderBase.OVector3>();
List<RenderBase.OVector3> normals = new List<RenderBase.OVector3>();
List<RenderBase.OVector2> uvs = new List<RenderBase.OVector2>();
List<RenderBase.OVertex> currVertices = new List<RenderBase.OVertex>();
string name = string.Empty, oldName;
string[] lines = obj.Split((char)0xa);
foreach (string l in lines)
{
string line = l.Trim();
string[] lineParams = Regex.Split(line, "\\s+");
switch (lineParams[0])
{
case "v":
case "vn":
RenderBase.OVector3 pvec = new RenderBase.OVector3();
pvec.x = float.Parse(lineParams[1], CultureInfo.InvariantCulture);
pvec.y = float.Parse(lineParams[2], CultureInfo.InvariantCulture);
pvec.z = float.Parse(lineParams[3], CultureInfo.InvariantCulture);
if (lineParams[0] == "v") vertices.Add(pvec); else normals.Add(pvec);
break;
case "vt":
RenderBase.OVector2 tvec = new RenderBase.OVector2();
tvec.x = float.Parse(lineParams[1], CultureInfo.InvariantCulture);
tvec.y = float.Parse(lineParams[2], CultureInfo.InvariantCulture);
uvs.Add(tvec);
break;
case "f":
string[][] vtx = new string[lineParams.Length - 1][];
for (int i = 0; i < lineParams.Length - 1; i++)
{
vtx[i] = lineParams[i + 1].Split('/');
}
for (int i = 0; i < lineParams.Length - 1; i++)
{
RenderBase.OVertex vertex = new RenderBase.OVertex();
vertex.position = vertices[int.Parse(vtx[i][0]) - 1];
if (vtx[i].Length > 1 && vtx[i][1] != string.Empty) vertex.texture0 = uvs[int.Parse(vtx[i][1]) - 1];
if (vtx[i].Length > 2) vertex.normal = normals[int.Parse(vtx[i][2]) - 1];
vertex.diffuseColor = 0xffffffff;
if (i > 2)
{
currVertices.Add(currVertices[currVertices.Count - 3]);
currVertices.Add(currVertices[currVertices.Count - 2]);
currVertices.Add(vertex);
}
else
currVertices.Add(vertex);
}
break;
case "g":
oldName = name;
if (lineParams.Length > 1)
name = lineParams[1];
else
name = "mesh";
if (currVertices.Count > 0)
{
RenderBase.OMesh mesh = new RenderBase.OMesh();
mesh.vertices = currVertices;
mesh.name = oldName;
mesh.hasNormal = true;
mesh.texUVCount = 1;
model.mesh.Add(mesh);
currVertices = new List<RenderBase.OVertex>();
}
break;
}
}
if (currVertices.Count > 0)
{
RenderBase.OMesh mesh = new RenderBase.OMesh();
mesh.vertices = currVertices;
mesh.name = name;
mesh.hasNormal = true;
mesh.texUVCount = 1;
model.mesh.Add(mesh);
}
model.material.Add(new RenderBase.OMaterial());
output.model.Add(model);
return output;
}
