public void ResetMaterial(VisualMaterial visMat, Material mat)
{
this.visMat = visMat;
this.mat = mat;
currentFrame = 0;
updateCounter = 0;
}
protected override void ReadInternal(Reader reader)
{
flags = reader.ReadUInt32();
//UnityEngine.Debug.LogWarning("GEO: " + Offset + " - " + flags);
num_elements = reader.ReadUInt32();
off_visualMaterials = Pointer.Read(reader);
Pointer.DoAt(ref reader, off_visualMaterials, () => {
off_visualMaterials_array = new Pointer[num_elements];
visualMaterials = new VisualMaterial[num_elements];
for (int i = 0; i < num_elements; i++)
{
off_visualMaterials_array[i] = Pointer.Read(reader);
visualMaterials[i] = VisualMaterial.FromOffsetOrRead(off_visualMaterials_array[i], reader);
}
});
off_elements = Pointer.Read(reader);
off_uint1 = Pointer.Read(reader);
off_num_triangles = Pointer.Read(reader);
off_unk = Pointer.Read(reader);
unk1 = reader.ReadUInt32();
unk2 = reader.ReadUInt32();
Pointer.DoAt(ref reader, off_uint1, () => {
uint1 = new uint[num_elements];
for (int i = 0; i < num_elements; i++)
{
uint1[i] = reader.ReadUInt32();
}
});
Pointer.DoAt(ref reader, off_num_triangles, () => {
num_triangles = new uint[num_elements];
for (int i = 0; i < num_elements; i++)
{
num_triangles[i] = reader.ReadUInt32();
}
});
Pointer.DoAt(ref reader, off_elements, () => {
off_elements_array = new Pointer[num_elements];
for (int i = 0; i < num_elements; i++)
{
off_elements_array[i] = Pointer.Read(reader);
}
});
elements = new PS2OptimizedSDCStructureElement[num_elements];
for (int i = 0; i < num_elements; i++)
{
Pointer.DoAt(ref reader, off_elements_array[i], () => {
elements[i] = new PS2OptimizedSDCStructureElement(this, i);
elements[i].Read(reader);
});
}
}
public static ScriptNode Read(Reader reader, Pointer offset, Script script) {
MapLoader l = MapLoader.Loader;
ScriptNode sn = new ScriptNode(offset);
sn.script = script;
sn.param = reader.ReadUInt32();
sn.param_ptr = Pointer.GetPointerAtOffset(offset); // if parameter is pointer
if (Settings.s.platform == Settings.Platform.DC) reader.ReadUInt32();
if (Settings.s.mode == Settings.Mode.Rayman3GC) {
reader.ReadByte();
reader.ReadByte();
reader.ReadByte();
sn.type = reader.ReadByte();
reader.ReadByte();
reader.ReadByte();
sn.indent = reader.ReadByte();
reader.ReadByte();
} else {
reader.ReadByte();
reader.ReadByte();
sn.indent = reader.ReadByte();
sn.type = reader.ReadByte();
}
sn.nodeType = NodeType.Unknown;
if (Settings.s.aiTypes != null) sn.nodeType = Settings.s.aiTypes.GetNodeType(sn.type);
if (sn.param_ptr != null && sn.nodeType != NodeType.Unknown) {
//l.print("ScriptNode " + offset + " - " + sn.nodeType + " (" + sn.type + ") - " + sn.param_ptr);
if (sn.nodeType == NodeType.WayPointRef) {
WayPoint waypoint = WayPoint.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.String) {
Pointer.DoAt(ref reader, sn.param_ptr, () => {
string str = reader.ReadNullDelimitedString();
l.strings[sn.param_ptr] = str;
});
} else if (sn.nodeType == NodeType.ObjectTableRef) {
// In R2 some objects have object tables that aren't listed normally, but are referenced through scripts.
} else if (sn.nodeType == NodeType.Button) {
EntryAction.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.GameMaterialRef) {
GameMaterial.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.VisualMaterial) {
VisualMaterial.FromOffsetOrRead(sn.param_ptr, reader);
}
}
return sn;
}
private VisualMaterial ConvertMaterialSection(Section s)
{
VisualMaterial vm = new VisualMaterial(null);
Material m = (Material)s[0]["material"];
vm.ambientCoef = m.color * m.ambient;
vm.diffuseCoef = new Color(m.diffuse, m.diffuse, m.diffuse);
vm.specularCoef = new Color(m.specular, m.specular, m.specular);
vm.num_textures = 1;
if (m.isTextured)
{
MaterialTexture mt = (MaterialTexture)s[1][0]["texture"];
byte[] texName = s[1][1].data;
byte[] alphaName = s[1][2].data;
VisualMaterialTexture vmt = new VisualMaterialTexture();
/*foreach (TextureDictionary txd in txds) {
* Texture2D tex = txd.Lookup(texName, TextureDictionary.Type.Texture);
* if (tex != null) {
* vmt.texture = new TextureInfo(null) {
* width = (ushort)tex.width,
* height = (ushort)tex.height,
* Texture = tex
* };
* break;
* }
* }*/
vm.textures.Add(vmt);
}
else
{
vm.textures.Add(new VisualMaterialTexture()
{
texture = new TextureInfo(null)
{
width = 1,
height = 1,
Texture = Util.CreateDummyTexture()
}
});
}
return(vm);
}
private void FixedUpdate()
{
if (visualMaterial != visualMaterial_was)
{
switch (visualMaterial)
{
case VisualMaterial.normalMaterial:
SetMaterial(null);
break;
case VisualMaterial.canPlace:
SetMaterial(canPlaceMaterial);
break;
case VisualMaterial.cannotPlace:
SetMaterial(cannotPlaceMaterial);
break;
}
}
visualMaterial_was = visualMaterial;
}
public string ToString(Perso perso, TranslatedScript.TranslationSettings ts, bool advanced = false)
{
MapLoader l = MapLoader.Loader;
short mask = 0;
AITypes aiTypes = Settings.s.aiTypes;
Vector3 vector3 = new Vector3 {
x = 0, y = 0, z = 0
};
switch (nodeType)
{
case ScriptNode.NodeType.KeyWord: // KeyWordFunctionPtr
if (param < aiTypes.keywordTable.Length)
{
if (ts.exportMode)
{
if (aiTypes.keywordTable[param] == "Me")
{
return("this");
}
if (aiTypes.keywordTable[param] == "MainActor")
{
return("Controller.MainActor");
}
if (aiTypes.keywordTable[param] == "Nobody" || aiTypes.keywordTable[param] == "NoInput" || aiTypes.keywordTable[param] == "Nowhere" || aiTypes.keywordTable[param] == "NoGraph" || aiTypes.keywordTable[param] == "NoAction" || aiTypes.keywordTable[param] == "CapsNull")
{
return("null");
}
}
return(aiTypes.keywordTable[param]);
}
return("UnknownKeyword_" + param);
case ScriptNode.NodeType.Condition: // GetConditionFunctionPtr
if (param < aiTypes.conditionTable.Length)
{
return(aiTypes.conditionTable[param]);
}
return("UnknownCondition_" + param);
case ScriptNode.NodeType.Operator: // GetOperatorFunctionPtr
if (advanced)
{
if (param < aiTypes.operatorTable.Length)
{
return(aiTypes.operatorTable[param] + " (" + param + ")");
}
}
if (param < aiTypes.operatorTable.Length)
{
return(aiTypes.operatorTable[param]);
}
return("UnknownOperator_" + param);
case ScriptNode.NodeType.Function: // GetFunctionFunctionPtr
if (param < aiTypes.functionTable.Length)
{
return(aiTypes.functionTable[param]);
}
return("UnknownFunction_" + param);
case ScriptNode.NodeType.Procedure: // ProcedureFunctionReturn
if (param < aiTypes.procedureTable.Length)
{
return(aiTypes.procedureTable[param]);
}
return("UnknownProcedure_" + param);
case ScriptNode.NodeType.MetaAction: // meta action
if (param < aiTypes.metaActionTable.Length)
{
return(aiTypes.metaActionTable[param]);
}
return("UnknownMetaAction_" + param);
case ScriptNode.NodeType.BeginMacro:
return("BeginMacro");
case ScriptNode.NodeType.EndMacro:
return("EndMacro");
case ScriptNode.NodeType.Field:
if (param < aiTypes.fieldTable.Length)
{
return(aiTypes.fieldTable[param]);
}
return("UnknownField_" + param);
case ScriptNode.NodeType.DsgVarRef: // Dsg Var
if (perso != null && perso.brain != null && perso.brain.mind != null)
{
Mind mind = perso.brain.mind;
if (mind.dsgMem != null && mind.dsgMem.dsgVar != null)
{
if (param < mind.dsgMem.dsgVar.dsgVarInfos.Length)
{
return(mind.dsgMem.dsgVar.dsgVarInfos[param].NiceVariableName);
}
}
else if (mind.AI_model != null && mind.AI_model.dsgVar != null)
{
if (param < mind.AI_model.dsgVar.dsgVarInfos.Length)
{
return(mind.AI_model.dsgVar.dsgVarInfos[param].NiceVariableName);
}
}
}
return("dsgVar_" + param);
case ScriptNode.NodeType.Constant:
if (advanced)
{
return("Constant: " + BitConverter.ToInt32(BitConverter.GetBytes(param), 0));
}
return(BitConverter.ToInt32(BitConverter.GetBytes(param), 0).ToString());
case ScriptNode.NodeType.Real:
NumberFormatInfo nfi = new NumberFormatInfo()
{
NumberDecimalSeparator = "."
};
if (advanced)
{
return("Real: " + BitConverter.ToSingle(BitConverter.GetBytes(param), 0).ToString(nfi));
}
return(BitConverter.ToSingle(BitConverter.GetBytes(param), 0).ToString(nfi) + "f");
case ScriptNode.NodeType.Button: // Button/entryaction
EntryAction ea = EntryAction.FromOffset(param_ptr);
if (ea == null)
{
return("ERR_ENTRYACTION_NOTFOUND");
}
string eaName = (advanced ? ea.ToString() : ea.ToBasicString());
if (advanced)
{
return("Button: " + eaName + "(" + param_ptr + ")");
}
if (!ts.expandEntryActions && ea != null)
{
return("\"" + ea.ExportName + "\"");
}
return(eaName);
case ScriptNode.NodeType.ConstantVector:
return("Constant Vector: " + "0x" + param.ToString("x8")); // TODO: get from address
case ScriptNode.NodeType.Vector:
return("new Vector3"); // TODO: same
case ScriptNode.NodeType.Mask:
mask = (short)param; // TODO: as short
if (advanced)
{
return("Mask: " + (mask).ToString("x4"));
}
if (ts.exportMode)
{
return("\"" + (mask).ToString("x4") + "\"");
}
return("Mask(" + (mask).ToString("x4") + ")");
case ScriptNode.NodeType.ModuleRef:
if (advanced)
{
return("ModuleRef: " + "0x" + (param).ToString("x8"));
}
return("GetModule(" + (int)param + ")");
case ScriptNode.NodeType.DsgVarId:
if (advanced)
{
return("DsgVarId: " + "0x" + (param).ToString("x8"));
}
return("DsgVarId(" + param + ")");
case ScriptNode.NodeType.String:
string str = "ERR_STRING_NOTFOUND";
if (l.strings.ContainsKey(param_ptr))
{
str = l.strings[param_ptr];
}
if (advanced)
{
return("String: " + param_ptr + " (" + str + ")");
}
return("\"" + str + "\"");
case ScriptNode.NodeType.LipsSynchroRef:
return("LipsSynchroRef: " + param_ptr);
case ScriptNode.NodeType.FamilyRef:
if (advanced)
{
return("FamilyRef: " + param_ptr);
}
Family f = Family.FromOffset(param_ptr);
if (f != null)
{
return("GetFamily(\"" + f.name + "\")");
}
else
{
return("Family.FromOffset(\"" + param_ptr + "\")");
}
case ScriptNode.NodeType.PersoRef:
Perso argPerso = Perso.FromOffset(param_ptr);
if (argPerso != null && perso != null && argPerso.offset == perso.offset)
{
if (advanced)
{
return("PersoRef: this");
}
return("this");
}
string persoName = argPerso == null ? "ERR_PERSO_NOTFOUND" : argPerso.fullName;
if (advanced)
{
return("PersoRef: " + param_ptr + " (" + persoName + ")");
}
if (argPerso?.brain?.mind?.AI_model != null)
{
AIModel aiModel = argPerso.brain.mind.AI_model;
// Make sure to add a cast in case the AI Model is accessed
return("((" + aiModel.name + ")GetPerso(\"" + argPerso.namePerso + "\"))");
}
return("GetPerso(\"" + argPerso.namePerso + "\")");
case ScriptNode.NodeType.ActionRef:
State state = State.FromOffset(param_ptr);
string stateName = state == null ? "ERR_STATE_NOTFOUND" : state.ShortName;
if (advanced)
{
return("ActionRef: " + param_ptr + " " + stateName);
}
if (ts.useStateIndex)
{
return("GetAction(" + state.index.ToString() + ")");
}
return(stateName);
case ScriptNode.NodeType.SuperObjectRef:
if (advanced)
{
return("SuperObjectRef: " + param_ptr);
}
SuperObject so = SuperObject.FromOffset(param_ptr);
if (so != null)
{
return("GetSuperObject(\"" + so.Gao.name + "\")");
}
else
{
return("SuperObject.FromOffset(\"" + param_ptr + "\")");
}
case ScriptNode.NodeType.WayPointRef:
if (advanced)
{
return("WayPointRef: " + param_ptr);
}
return("WayPoint.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.TextRef:
if (l.localization == null)
{
return("TextRef");
}
if (advanced)
{
return("TextRef: " + param + " (" + l.localization.GetTextForHandleAndLanguageID((int)param, 0) + ")");
}
if (ts.expandStrings)
{
return("\"" + l.localization.GetTextForHandleAndLanguageID((int)param, 0) + "\""); // Preview in english
}
else
{
return("new TextReference(" + (int)param + ")");
}
case ScriptNode.NodeType.ComportRef:
Behavior comportRef = Behavior.FromOffset(param_ptr);
if (comportRef == null)
{
if (advanced)
{
return("ComportRef: " + param_ptr + " (null)");
}
return("null");
}
else
{
return(comportRef.ShortName);
//string type = comportRef.type == Behavior.BehaviorType.Normal ? "normalBehavior" : "reflexBehavior";
//return type + "[" + script.behaviorOrMacro.aiModel.GetBehaviorIndex(comportRef) + "]";
}
case ScriptNode.NodeType.SoundEventRef:
if (advanced)
{
return("SoundEventRef: " + (int)param);
}
return("SoundEvent.FromID(0x" + ((int)param).ToString("X8") + ")");
case ScriptNode.NodeType.ObjectTableRef:
if (advanced)
{
return("ObjectTableRef: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string objectListJson = ObjectList.FromOffset(param_ptr).ToJSON();
string objectListHash = HashUtils.MD5Hash(objectListJson);
return("ObjectList.FromHash(\"" + objectListHash + "\")");
}
return("ObjectTable.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.GameMaterialRef:
if (advanced)
{
return("GameMaterialRef: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string gmtJson = GameMaterial.FromOffset(param_ptr).ToJSON();
string gmtHash = HashUtils.MD5Hash(gmtJson);
return("GameMaterial.FromHash(\"" + gmtHash + "\")");
}
return("GameMaterial.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.ParticleGenerator:
return("ParticleGenerator: " + "0x" + (param).ToString("x8"));
case ScriptNode.NodeType.VisualMaterial:
if (advanced)
{
return("VisualMaterial: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string vmtJson = VisualMaterial.FromOffset(param_ptr).ToJSON();
string vmtHash = HashUtils.MD5Hash(vmtJson);
return("VisualMaterial.FromHash(\"" + vmtHash + "\")");
}
return("VisualMaterial.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.ModelRef: // ModelCast
if (advanced)
{
return("AIModel: " + param_ptr);
}
AIModel model = AIModel.FromOffset(param_ptr);
return(model != null ? model.name : "null");
case ScriptNode.NodeType.DataType42:
if (advanced)
{
return("EvalDataType42: " + "0x" + (param).ToString("x8"));
}
return("EvalDataType42(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.CustomBits:
if (advanced)
{
return("CustomBits: " + "0x" + (param).ToString("x8"));
}
if (ts.exportMode)
{
return("0x" + (param).ToString("x8"));
}
return("CustomBits(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.Caps:
if (advanced)
{
return("Caps: " + "0x" + (param).ToString("x8"));
}
if (ts.exportMode)
{
return("0x" + (param).ToString("x8"));
}
return("Caps(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.SubRoutine:
if (advanced)
{
return("Eval SubRoutine: " + param_ptr);
}
Macro macro = Macro.FromOffset(param_ptr);
if (macro == null)
{
return("null");
}
return("evalMacro(" + macro.ShortName + ");");
case ScriptNode.NodeType.Null:
return("null");
case ScriptNode.NodeType.GraphRef:
if (advanced)
{
return("Graph: " + "0x" + (param).ToString("x8"));
}
return("Graph.FromOffset(\"" + param_ptr + "\")");
}
return("unknown");
}
public static Sector Read(Reader reader, Pointer offset, SuperObject so)
{
MapLoader l = MapLoader.Loader;
Sector s = new Sector(offset, so);
s.name = "Sector @ " + offset + ", SPO @ " + so.offset;
//l.print(s.name);
if (Settings.s.engineVersion <= Settings.EngineVersion.Montreal)
{
if (Settings.s.game == Settings.Game.TTSE)
{
reader.ReadUInt32(); // always 1 or 0. whether the sector is active or not?
}
Pointer off_collideObj = Pointer.Read(reader);
Pointer.DoAt(ref reader, off_collideObj, () => {
//CollideMeshObject collider = CollideMeshObject.Read(reader, off_collideObj);
// This has the exact same structure as a CollideMeshObject but with a sector superobject as material for the collieMeshElements
});
LinkedList <int> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double); // "environments list"
LinkedList <int> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double); // "surface list"
}
s.persos = LinkedList <Perso> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double);
s.staticLights = LinkedList <LightInfo> .Read(ref reader, Pointer.Current(reader),
(off_element) => {
LightInfo li = l.FromOffsetOrRead <LightInfo>(reader, off_element);
if (li != null)
{
li.containingSectors.Add(s);
}
return(li);
},
flags : LinkedList.Flags.ElementPointerFirst
| LinkedList.Flags.ReadAtPointer
| ((Settings.s.hasLinkedListHeaderPointers) ?
LinkedList.Flags.HasHeaderPointers :
LinkedList.Flags.NoPreviousPointersForDouble),
type : LinkedList.Type.Minimize
);
s.dynamicLights = LinkedList <int> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double);
if (Settings.s.engineVersion <= Settings.EngineVersion.Montreal)
{
LinkedList <int> .ReadHeader(reader, Pointer.Current(reader)); // "streams list", probably related to water
}
s.neighbors = LinkedList <NeighborSector> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Minimize);
s.sectors_unk1 = LinkedList <NeighborSector> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Minimize);
s.sectors_unk2 = LinkedList <Sector> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Minimize);
LinkedList <int> .ReadHeader(reader, Pointer.Current(reader)); // Placeholder
LinkedList <int> .ReadHeader(reader, Pointer.Current(reader)); // Placeholder
if (Settings.s.engineVersion > Settings.EngineVersion.Montreal)
{
s.sectorBorder = BoundingVolume.Read(reader, Pointer.Current(reader), BoundingVolume.Type.Box);
reader.ReadUInt32();
if (Settings.s.game == Settings.Game.R2Revolution || Settings.s.game == Settings.Game.LargoWinch)
{
s.isSectorVirtual = reader.ReadByte();
reader.ReadByte();
s.sectorPriority = reader.ReadByte();
reader.ReadByte();
}
else
{
s.isSectorVirtual = reader.ReadByte();
reader.ReadByte();
reader.ReadByte();
s.sectorPriority = reader.ReadByte();
if (Settings.s.engineVersion <= Settings.EngineVersion.R2)
{
s.off_skyMaterial = Pointer.Read(reader);
s.skyMaterial = VisualMaterial.FromOffsetOrRead(s.off_skyMaterial, reader);
}
else
{
reader.ReadUInt32();
}
reader.ReadByte();
if (Settings.s.hasNames)
{
s.name = reader.ReadString(0x104);
l.print(s.name);
}
}
}
else
{
if (Settings.s.engineVersion == Settings.EngineVersion.Montreal)
{
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
}
if (Settings.s.game != Settings.Game.TTSE)
{
reader.ReadUInt32();
}
Pointer off_name = Pointer.Read(reader);
Pointer.DoAt(ref reader, off_name, () => {
s.name = reader.ReadNullDelimitedString() + " @ " + offset;
});
}
/*if(num_subsectors_unk > 0 && off_subsector_unk_first != null) { // only for father sector
* R3Pointer off_subsector_next = off_subsector_unk_first;
* for (int i = 0; i < num_subsectors_unk; i++) {
* R3Pointer.Goto(ref reader, off_subsector_next);
* R3Pointer off_subsector = R3Pointer.Read(reader);
* off_subsector_next = R3Pointer.Read(reader);
* R3Pointer off_subsector_prev = R3Pointer.Read(reader);
* R3Pointer off_sector_start = R3Pointer.Read(reader);
* if (off_subsector != null) {
* sect.neighborsPointers.Add(off_subsector);
* }
* }
* }*/
l.sectors.Add(s);
return(s);
}
public void Read(Reader reader)
{
offset = Pointer.Current(reader);
if (geo.Type == 4 || geo.Type == 5 || geo.Type == 6)
{
// Optimized
num_vertices_actual = reader.ReadUInt32();
num_vertices = reader.ReadUInt32();
num_uvs = reader.ReadUInt32();
unk3 = reader.ReadUInt32();
}
else
{
num_vertices = geo.num_triangles[index] * 3;
num_uvs = (num_vertices + 3) >> 2;
num_vertices_actual = num_vertices;
}
VisualMaterial vm = geo.visualMaterials[index];
bool hasUv0 = true, hasUv1 = false, hasNormals = false;
uint num_textures = 1;
if (vm != null && vm.num_textures_in_material > 0)
{
hasUv0 = false;
num_textures = vm.num_textures_in_material;
for (int i = 0; i < vm.num_textures_in_material; i++)
{
switch (vm.textures[i].uvFunction)
{
case 4: hasNormals = true; break;
case 1: hasUv1 = true; break;
case 0: hasUv0 = true; break;
}
}
}
vertices = new Vertex[num_vertices];
for (int i = 0; i < num_vertices; i++)
{
vertices[i] = new Vertex(reader);
}
if (geo.Type == 1 && Settings.s.game == Settings.Game.R3)
{
uvUnoptimized = new UVUnoptimized[num_vertices];
for (int i = 0; i < uvUnoptimized.Length; i++)
{
uvUnoptimized[i] = new UVUnoptimized(reader);
}
}
else
{
if (hasUv0)
{
uv0 = new TexCoord[num_uvs];
for (int i = 0; i < uv0.Length; i++)
{
uv0[i] = new TexCoord(reader);
}
}
if (hasUv1)
{
uv1 = new TexCoord[num_uvs];
for (int i = 0; i < uv1.Length; i++)
{
uv1[i] = new TexCoord(reader);
}
}
if (hasNormals)
{
normals = new Normal[num_vertices];
for (int i = 0; i < normals.Length; i++)
{
normals[i] = new Normal(reader);
}
}
if ((geo.flags & 0x100) != 0)
{
uv_unk = new TexCoord[num_uvs];
for (int i = 0; i < uv_unk.Length; i++)
{
uv_unk[i] = new TexCoord(reader);
}
}
}
colors = new VertexColor[num_textures][]; // Seem to be in a color-like format? 7F 7F 7F 80, repeated 4 times
for (int i = 0; i < colors.Length; i++)
{
colors[i] = new VertexColor[num_uvs];
for (int j = 0; j < colors[i].Length; j++)
{
colors[i][j] = new VertexColor(reader);
}
}
if (geo.isSinus != 0)
{
sinusState = new VectorForSinusEffect[num_uvs];
for (int i = 0; i < sinusState.Length; i++)
{
sinusState[i] = new VectorForSinusEffect(reader);
}
}
if ((index < geo.num_elements - 1 && Pointer.Current(reader) != geo.off_elements_array[index + 1]) ||
(index == geo.num_elements - 1 && Pointer.Current(reader) != geo.off_uint1))
{
UnityEngine.Debug.LogWarning("B " + geo.Offset + " - " + offset + " - " + hasUv0 + " - " + hasUv1 + " - " + hasNormals);
}
else
{
//UnityEngine.Debug.LogWarning("G " + geo.Offset + " - " + offset + " - " + hasUv0 + " - " + hasUv1 + " - " + hasUv4);
}
/*normals = new Vertex[num_vertices];
* for (int i = 0; i < num_vertices; i++) {
* normals[i] = new Vertex(reader);
* }*/
}
void UpdateAnimations()
{
if (cont.LoadState == Controller.State.Finished)
{
/*if(MapLoader.Loader.visualMaterials != null) {
* for (int i = 0; i < MapLoader.Loader.visualMaterials.Count; i++) {
* VisualMaterial vm = MapLoader.Loader.visualMaterials[i];
* if (vm.animTextures.Count > 0 && !vm.IsLockedAnimatedTexture) {
* vm.currentAnimTexture %= vm.animTextures.Count;
* vm.animTextures[vm.currentAnimTexture].currentTime += updateCounter * modifier;
* while (vm.animTextures[vm.currentAnimTexture].currentTime > vm.animTextures[vm.currentAnimTexture].time) {
* float rest = vm.animTextures[vm.currentAnimTexture].currentTime - vm.animTextures[vm.currentAnimTexture].time;
* vm.animTextures[vm.currentAnimTexture].currentTime = 0;
* if (vm.animTextures[vm.currentAnimTexture].time <= 0) break;
* vm.currentAnimTexture = (vm.currentAnimTexture + 1) % vm.animTextures.Count;
* vm.animTextures[vm.currentAnimTexture].currentTime = rest;
* }
* }
* }
* }*/
for (int i = 0; i < materials.Count; i++)
{
MultiTextureMaterial mtm = materials[i];
if (mtm != null)
{
if (mtm.visMat != null)
{
VisualMaterial vm = mtm.visMat;
if (vm.animTextures.Count > 0 && !vm.IsLockedAnimatedTexture)
{
vm.currentAnimTexture %= vm.animTextures.Count;
vm.animTextures[vm.currentAnimTexture].currentTime += updateCounter * modifier;
float time = vm.animTextures[vm.currentAnimTexture].time;
if (!UnitySettings.IsRaymapGame && time <= 0)
{
time = defaultTime;
}
while (vm.animTextures[vm.currentAnimTexture].currentTime > time)
{
time = vm.animTextures[vm.currentAnimTexture].time;
if (!UnitySettings.IsRaymapGame && time <= 0)
{
time = defaultTime;
}
float rest = vm.animTextures[vm.currentAnimTexture].currentTime - time;
vm.animTextures[vm.currentAnimTexture].currentTime = 0;
if (time <= 0)
{
break;
}
vm.currentAnimTexture = (vm.currentAnimTexture + 1) % vm.animTextures.Count;
vm.animTextures[vm.currentAnimTexture].currentTime = rest;
}
}
}
else if (mtm.visMatROM != null)
{
OpenSpace.ROM.VisualMaterial vm = mtm.visMatROM;
if (vm.num_textures > 0) // && !vm.IsLockedAnimatedTexture) {
{
mtm.CurrentTextureROM %= vm.num_textures;
mtm.CurrentTextureROMTime += updateCounter * modifier;
float animTime = vm.textures.Value.vmTex[mtm.CurrentTextureROM].time / 30f;
while (mtm.CurrentTextureROMTime > animTime)
{
float rest = mtm.CurrentTextureROMTime - animTime;
//mtm.CurrentTextureROMTime = 0;
if (animTime <= 0)
{
break;
}
mtm.CurrentTextureROM = (mtm.CurrentTextureROM + 1) % vm.num_textures;
mtm.CurrentTextureROMTime = rest;
animTime = vm.textures.Value.vmTex[mtm.CurrentTextureROM].time / 30f;
}
}
}
}
}
materials.RemoveAll(m => m == null || m.gameObject == null);
}
}
// Update is called once per frame
void Update()
{
if (_enableLighting != enableLighting)
{
_enableLighting = enableLighting;
}
if (_enableFog != enableFog)
{
_enableFog = enableFog;
}
if (_luminosity != luminosity)
{
_luminosity = luminosity;
}
if (_saturate != saturate)
{
_saturate = saturate;
}
Shader.SetGlobalFloat("_DisableLighting", enableLighting ? 0f : 1f);
Shader.SetGlobalFloat("_DisableFog", enableFog ? 0f : 1f);
Shader.SetGlobalFloat("_Luminosity", luminosity);
Shader.SetGlobalFloat("_Saturate", saturate ? 1f : 0f);
// Update background color or material
Color? backgroundColor = null;
VisualMaterial skyMaterial = null;
Sector activeBackgroundSector = null;
/*if (MapLoader.Loader.globals != null && MapLoader.Loader.globals.backgroundGameMaterial != null && MapLoader.Loader.globals.backgroundGameMaterial.visualMaterial != null) {
* skyMaterial = MapLoader.Loader.globals.backgroundGameMaterial.visualMaterial;
* } else {*/
if (sectorManager != null && sectorManager.Sectors != null && sectorManager.Sectors.Count > 0)
{
foreach (Sector s in sectorManager.Sectors)
{
if (!s.Active)
{
continue;
}
if (s.skyMaterial != null && s.skyMaterial.textures.Count > 0 && s.skyMaterial.textures.Where(t => t.texture != null).Count() > 0)
{
skyMaterial = s.skyMaterial;
activeBackgroundSector = s;
break;
}
else
{
foreach (LightBehaviour li in s.Lights)
{
if (li == null)
{
continue;
}
if (li.lightInfo.type == 6)
{
backgroundColor = li.lightInfo.background_color;
break;
}
}
}
}
}
//} TODO: Implement global sky material
/*if (skyMaterial != null) {
* backgroundPanel.gameObject.SetActive(true);
* if (backgroundMaterial != skyMaterial) {
* backgroundMaterial = skyMaterial;
* Material skyboxMat = skyMaterial.GetMaterial();
* backgroundPanel.sharedMaterial = skyboxMat;
* }
* //skyboxMat.SetFloat("_DisableLighting", 1f);
* backgroundPanel.sharedMaterial.SetFloat("_DisableLightingLocal", 1f);
* if (activeBackgroundSector != null) {
* if (activeBackgroundSector != previousActiveBackgroundSector) {
* //backgroundPanel.material.SetFloat("_DisableLightingLocal", 0f);
* sectorManager.ApplySectorLighting(activeBackgroundSector, backgroundPanel.gameObject, LightInfo.ObjectLightedFlag.Environment);
* previousActiveBackgroundSector = activeBackgroundSector;
* }
* } else {
* //backgroundPanel.material.SetFloat("_DisableLighting", 1f);
* }
* //RenderSettings.skybox = skyboxMat;
* //Camera.main.clearFlags = CameraClearFlags.Skybox;
* } else {
* backgroundPanel.gameObject.SetActive(false);
* //RenderSettings.skybox = null;
* //Camera.main.clearFlags = CameraClearFlags.SolidColor;
* }
* if (backgroundColor.HasValue) {
* Camera.main.backgroundColor = backgroundColor.Value;
* //Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, backgroundColor.Value, 0.5f * Time.deltaTime);
* } else {
* Camera.main.backgroundColor = Color.black;
* //Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, Color.black, 0.5f * Time.deltaTime);
* }*/
/*if (useFog && Camera.main.renderingPath == RenderingPath.DeferredShading) {
* // Fog doesn't work for deferred
* Camera.main.renderingPath = RenderingPath.Forward;
* }
* bool fogSet = false;
* bool ambientSet = false;
* if (simulateSectorLoading) {
* List<LightInfo> ambientLights = new List<LightInfo>();
* List<LightInfo> fogLights = new List<LightInfo>();
* for (int i = 0; i < lights.Count; i++) {
* LightInfo l = lights[i];
* if (l.containingSectors.FirstOrDefault(s => (neighborSectorLights ? s.Loaded : s.Active)) != null) {
* l.Light.Activate();
* if (l.type == 6) fogLights.Add(l);
* if (l.type == 4) ambientLights.Add(l);
* } else {
* l.Light.Deactivate();
* }
* }
* if (useAmbientColor) {
* Color ambientLight = Color.black;
* if (ambientLights.Count > 0) {
* LightInfo l = ambientLights[0];
* ambientLight = l.color;
* }
* RenderSettings.ambientLight = ambientLight;
* }
*
* if (useFog) {
* if (fogLights.Count > 0) {
* LightInfo l = fogLights[0];
* float minFogDist = Vector3.Distance(fogLights[0].Light.transform.position, Camera.main.transform.position);
* for (int i = 1; i < fogLights.Count; i++) {
* float fogDist = Vector3.Distance(fogLights[i].Light.transform.position, Camera.main.transform.position);
* if (fogDist < l.far && fogDist < minFogDist) {
* l = fogLights[i];
* }
* }
* RenderSettings.fog = true;
* RenderSettings.fogColor = Color.Lerp(RenderSettings.fogColor, l.Light.color, 0.5f * Time.deltaTime);
* RenderSettings.fogMode = FogMode.Linear;
* RenderSettings.fogStartDistance = Mathf.Lerp(RenderSettings.fogStartDistance, l.near, 0.5f * Time.deltaTime);
* RenderSettings.fogEndDistance = Mathf.Lerp(RenderSettings.fogEndDistance, l.far, 0.5f * Time.deltaTime);
* Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, l.Light.backgroundColor, 0.5f * Time.deltaTime);
* fogSet = true;
* } else {
* Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, Color.black, 0.5f * Time.deltaTime);
* RenderSettings.fogColor = Color.Lerp(RenderSettings.fogColor, Color.black, 0.5f * Time.deltaTime);
* RenderSettings.fogStartDistance += 50 * Time.deltaTime;
* RenderSettings.fogEndDistance += 50 * Time.deltaTime;
* if (RenderSettings.fogStartDistance > 500) {
* RenderSettings.fog = false;
* }
* }
* }
* }
* else {
*/
/*foreach(LightInfo l in Lights) {
* l.Light.Activate();
* }*/
//}
}
public EDsgVar GetExportableDsgVar(DsgVarInfoEntry infoEntry)
{
EDsgVar d = new EDsgVar();
d.type = infoEntry.type;
if (infoEntry.value == null)
{
return(d);
}
switch (infoEntry.type)
{
default:
d.value = infoEntry.value;
break;
case DsgVarInfoEntry.DsgVarType.None:
break;
case DsgVarInfoEntry.DsgVarType.List: // TODO: figure out lists
break;
case DsgVarInfoEntry.DsgVarType.Comport: // TODO: comport
break;
case DsgVarInfoEntry.DsgVarType.Action: // TODO: action
break;
case DsgVarInfoEntry.DsgVarType.Input: // TODO: check if this works
//d.value = infoEntry.value
break;
case DsgVarInfoEntry.DsgVarType.SoundEvent: // TODO: check
break;
case DsgVarInfoEntry.DsgVarType.Light: // TODO: check
break;
case DsgVarInfoEntry.DsgVarType.GameMaterial:
d.value = HashUtils.MD5Hash(GameMaterial.FromOffset((Pointer)(infoEntry.value)).ToJSON());
break;
case DsgVarInfoEntry.DsgVarType.VisualMaterial:
d.value = HashUtils.MD5Hash(VisualMaterial.FromOffset((Pointer)(infoEntry.value)).ToJSON());
break;
case DsgVarInfoEntry.DsgVarType.Perso:
d.value = Perso.FromOffset((Pointer)(infoEntry.value))?.namePerso;
break;
case DsgVarInfoEntry.DsgVarType.Waypoint: // TODO
d.value = ((Pointer)infoEntry.value).ToString();
break;
case DsgVarInfoEntry.DsgVarType.Graph: // TODO
d.value = ((Pointer)infoEntry.value).ToString();
break;
case DsgVarInfoEntry.DsgVarType.Text: // TODO: check
goto default;
case DsgVarInfoEntry.DsgVarType.SuperObject: // TODO: check
break;
case DsgVarInfoEntry.DsgVarType.SOLinks: // TODO
break;
case DsgVarInfoEntry.DsgVarType.PersoArray:
List <string> persoNames = new List <string>();
foreach (object persoPointer in (object[])infoEntry.value)
{
if (persoPointer == null)
{
continue;
}
if (!(persoPointer is Pointer))
{
persoNames.Add("Not a valid pointer: " + (persoPointer).ToString()); // TODO: fix
continue;
}
Perso perso = Perso.FromOffset((Pointer)persoPointer);
if (perso != null)
{
persoNames.Add(perso.namePerso);
}
else
{
persoNames.Add("NullPointer");
}
}
break;
case DsgVarInfoEntry.DsgVarType.WayPointArray: // TODO
break;
case DsgVarInfoEntry.DsgVarType.TextArray: // TODO: check
goto default;
//break;
case DsgVarInfoEntry.DsgVarType.TextRefArray: // TODO: check
goto default;
case DsgVarInfoEntry.DsgVarType.Array6:
break;
case DsgVarInfoEntry.DsgVarType.Array9:
break;
case DsgVarInfoEntry.DsgVarType.SoundEventArray: // TODO: check
goto default;
case DsgVarInfoEntry.DsgVarType.Array11:
break;
case DsgVarInfoEntry.DsgVarType.Way:
break;
case DsgVarInfoEntry.DsgVarType.ActionArray: // TODO
break;
case DsgVarInfoEntry.DsgVarType.SuperObjectArray: // TODO
break;
}
return(d);
}
async Task LoadLVL()
{
loadingState = "Loading level memory";
await WaitIfNecessary();
files_array[Mem.Lvl].GotoHeader();
Reader reader = files_array[Mem.Lvl].reader;
long totalSize = reader.BaseStream.Length;
//reader.ReadUInt32();
if (Settings.s.game == Settings.Game.R3 &&
(Settings.s.platform == Settings.Platform.PC ||
Settings.s.platform == Settings.Platform.Xbox ||
Settings.s.platform == Settings.Platform.Xbox360 ||
Settings.s.platform == Settings.Platform.PS3))
{
reader.ReadUInt32(); // fix checksum?
}
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
if (Settings.s.platform == Settings.Platform.PC ||
Settings.s.platform == Settings.Platform.Xbox ||
Settings.s.platform == Settings.Platform.Xbox360 ||
Settings.s.platform == Settings.Platform.PS3)
{
if (Settings.s.game == Settings.Game.R3)
{
string timeStamp = reader.ReadString(0x18);
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
}
else if (Settings.s.game == Settings.Game.RM ||
Settings.s.game == Settings.Game.RA ||
Settings.s.game == Settings.Game.Dinosaur)
{
reader.ReadUInt32();
reader.ReadUInt32();
}
}
reader.ReadBytes(0x104); // vignette
if (Settings.s.game != Settings.Game.Dinosaur)
{
reader.ReadUInt32();
}
loadingState = "Loading level textures";
await ReadTexturesLvl(reader, Pointer.Current(reader));
if ((Settings.s.platform == Settings.Platform.PC ||
Settings.s.platform == Settings.Platform.Xbox ||
Settings.s.platform == Settings.Platform.Xbox360 ||
Settings.s.platform == Settings.Platform.PS3) &&
!hasTransit && Settings.s.game != Settings.Game.Dinosaur)
{
Pointer off_lightMapTexture = Pointer.Read(reader); // g_p_stLMTexture
Pointer.DoAt(ref reader, off_lightMapTexture, () => {
lightmapTexture = TextureInfo.Read(reader, off_lightMapTexture);
});
if (Settings.s.game == Settings.Game.R3)
{
Pointer off_overlightTexture = Pointer.Read(reader); // *(_DWORD *)(GLI_BIG_GLOBALS + 370068)
Pointer.DoAt(ref reader, off_overlightTexture, () => {
overlightTexture = TextureInfo.Read(reader, off_overlightTexture);
});
}
}
Pointer off_animBankLvl = null;
if (Settings.s.game == Settings.Game.Dinosaur)
{
// animation bank is read right here.
off_animBankLvl = Pointer.Current(reader); // Note: only one 0x104 bank in fix.
print("Lvl animation bank address: " + off_animBankLvl);
animationBanks = new AnimationBank[5];
AnimationBank[] banks = AnimationBank.Read(reader, off_animBankLvl, 0, 1, files_array[Mem.LvlKeyFrames]);
animationBanks[0] = banks[0];
}
loadingState = "Loading globals";
await WaitIfNecessary();
globals.off_transitDynamicWorld = null;
globals.off_actualWorld = Pointer.Read(reader);
globals.off_dynamicWorld = Pointer.Read(reader);
if (Settings.s.game == Settings.Game.R3 &&
(Settings.s.platform == Settings.Platform.PC ||
Settings.s.platform == Settings.Platform.Xbox ||
Settings.s.platform == Settings.Platform.Xbox360 ||
Settings.s.platform == Settings.Platform.PS3))
{
reader.ReadUInt32(); // ???
}
globals.off_inactiveDynamicWorld = Pointer.Read(reader);
globals.off_fatherSector = Pointer.Read(reader); // It is I, Father Sector.
globals.off_firstSubMapPosition = Pointer.Read(reader);
globals.num_always = reader.ReadUInt32();
globals.spawnablePersos = LinkedList <Perso> .ReadHeader(reader, Pointer.Current(reader), LinkedList.Type.Double);
globals.off_always_reusableSO = Pointer.Read(reader); // There are (num_always) empty SuperObjects starting with this one.
globals.off_always_reusableUnknown1 = Pointer.Read(reader); // (num_always) * 0x2c blocks
globals.off_always_reusableUnknown2 = Pointer.Read(reader); // (num_always) * 0x4 blocks
// Read object types
objectTypes = new ObjectType[3][];
for (uint i = 0; i < 3; i++)
{
Pointer off_names_header = Pointer.Current(reader);
Pointer off_names_first = Pointer.Read(reader);
Pointer off_names_last = Pointer.Read(reader);
uint num_names = reader.ReadUInt32();
ReadObjectNamesTable(reader, off_names_first, num_names, i);
}
Pointer off_light = Pointer.Read(reader); // the offset of a light. It's just an ordinary light.
Pointer off_characterLaunchingSoundEvents = Pointer.Read(reader);
Pointer off_collisionGeoObj = Pointer.Read(reader);
Pointer off_staticCollisionGeoObj = Pointer.Read(reader);
if (!hasTransit)
{
reader.ReadUInt32(); // viewport related <--- cameras in here
}
Pointer off_unknown_first = Pointer.Read(reader);
Pointer off_unknown_last = Pointer.Read(reader);
uint num_unknown = reader.ReadUInt32();
families = LinkedList <Family> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double);
Pointer off_alwaysActiveCharacters_first = Pointer.Read(reader);
Pointer off_alwaysActiveCharacters_last = Pointer.Read(reader);
uint num_alwaysActiveChars = reader.ReadUInt32();
if (!hasTransit)
{
Pointer off_mainCharacters_first = Pointer.Read(reader);
Pointer off_mainCharacters_last = Pointer.Read(reader);
uint num_mainCharacters_entries = reader.ReadUInt32();
}
reader.ReadUInt32(); // only used if there was no transit in the previous lvl. Always 00165214 in R3GC?
reader.ReadUInt32(); // related to "SOL". What is this? Good question.
reader.ReadUInt32(); // same
if (Settings.s.game != Settings.Game.Dinosaur)
{
reader.ReadUInt32(); // same
}
Pointer off_cineManager = Pointer.Read(reader);
byte unk = reader.ReadByte();
byte IPO_numRLItables = reader.ReadByte();
reader.ReadUInt16();
Pointer off_COL_taggedFacesTable = Pointer.Read(reader);
uint num_COL_maxTaggedFaces = reader.ReadUInt32();
off_collisionGeoObj = Pointer.Read(reader);
off_staticCollisionGeoObj = Pointer.Read(reader);
// The ptrsTable seems to be related to sound events. Perhaps cuuids.
reader.ReadUInt32();
if (Settings.s.game == Settings.Game.Dinosaur)
{
for (int i = 0; i < 50; i++)
{
reader.ReadUInt32();
}
// Actually, the previous uint is an amount for this array of uints, but it's padded to always be 50 long
}
uint num_ptrsTable = reader.ReadUInt32();
if (Settings.s.game == Settings.Game.R3)
{
uint bool_ptrsTable = reader.ReadUInt32();
}
Pointer off_ptrsTable = Pointer.Read(reader);
uint num_internalStructure = num_ptrsTable;
if (Settings.s.mode == Settings.Mode.Rayman3GC)
{
reader.ReadUInt32();
}
Pointer off_internalStructure_first = Pointer.Read(reader);
Pointer off_internalStructure_last = Pointer.Read(reader);
if (!hasTransit && Settings.s.game == Settings.Game.R3)
{
uint num_geometric = reader.ReadUInt32();
Pointer off_array_geometric = Pointer.Read(reader);
Pointer off_array_geometric_RLI = Pointer.Read(reader);
Pointer off_array_transition_flags = Pointer.Read(reader);
}
else if (Settings.s.game == Settings.Game.RA ||
Settings.s.game == Settings.Game.RM ||
Settings.s.game == Settings.Game.Dinosaur ||
Settings.s.game == Settings.Game.DDPK)
{
uint num_unk = reader.ReadUInt32();
Pointer unk_first = Pointer.Read(reader);
if (Settings.s.game != Settings.Game.Dinosaur)
{
Pointer unk_last = Pointer.Read(reader);
}
}
uint num_visual_materials = reader.ReadUInt32();
Pointer off_array_visual_materials = Pointer.Read(reader);
if (Settings.s.mode != Settings.Mode.RaymanArenaGC &&
Settings.s.mode != Settings.Mode.RaymanArenaGCDemo &&
Settings.s.mode != Settings.Mode.DonaldDuckPKGC)
{
Pointer off_dynamic_so_list = Pointer.Read(reader);
// Parse SO list
Pointer.DoAt(ref reader, off_dynamic_so_list, () => {
LinkedList <SuperObject> .ReadHeader(reader, off_dynamic_so_list);
/*Pointer off_so_list_first = Pointer.Read(reader);
* Pointer off_so_list_last = Pointer.Read(reader);
* Pointer off_so_list_current = off_so_list_first;
* uint num_so_list = reader.ReadUInt32();*/
/*if (experimentalObjectLoading) {
* for (uint i = 0; i < num_so_list; i++) {
* R3Pointer.Goto(ref reader, off_so_list_current);
* R3Pointer off_so_list_next = R3Pointer.Read(reader);
* R3Pointer off_so_list_prev = R3Pointer.Read(reader);
* R3Pointer off_so_list_start = R3Pointer.Read(reader);
* R3Pointer off_so = R3Pointer.Read(reader);
* R3Pointer.Goto(ref reader, off_so);
* ParseSuperObject(reader, off_so, true, true);
* off_so_list_current = off_so_list_next;
* }
* }*/
});
}
// Parse materials list
loadingState = "Loading visual materials";
await WaitIfNecessary();
Pointer.DoAt(ref reader, off_array_visual_materials, () => {
for (uint i = 0; i < num_visual_materials; i++)
{
Pointer off_material = Pointer.Read(reader);
Pointer.DoAt(ref reader, off_material, () => {
//print(Pointer.Current(reader));
visualMaterials.Add(VisualMaterial.Read(reader, off_material));
});
}
});
if (hasTransit)
{
loadingState = "Loading transit memory";
await WaitIfNecessary();
Pointer off_transit = new Pointer(16, files_array[Mem.Transit]); // It's located at offset 20 in transit
Pointer.DoAt(ref reader, off_transit, () => {
if (Settings.s.platform == Settings.Platform.PC ||
Settings.s.platform == Settings.Platform.Xbox ||
Settings.s.platform == Settings.Platform.Xbox360 ||
Settings.s.platform == Settings.Platform.PS3)
{
Pointer off_lightMapTexture = Pointer.Read(reader); // g_p_stLMTexture
Pointer.DoAt(ref reader, off_lightMapTexture, () => {
lightmapTexture = TextureInfo.Read(reader, off_lightMapTexture);
});
if (Settings.s.game == Settings.Game.R3)
{
Pointer off_overlightTexture = Pointer.Read(reader); // *(_DWORD *)(GLI_BIG_GLOBALS + 370068)
Pointer.DoAt(ref reader, off_overlightTexture, () => {
overlightTexture = TextureInfo.Read(reader, off_overlightTexture);
});
}
}
globals.off_transitDynamicWorld = Pointer.Read(reader);
globals.off_actualWorld = Pointer.Read(reader);
globals.off_dynamicWorld = Pointer.Read(reader);
globals.off_inactiveDynamicWorld = Pointer.Read(reader);
});
}
// Parse actual world & always structure
loadingState = "Loading families";
await WaitIfNecessary();
ReadFamilies(reader);
loadingState = "Loading superobject hierarchy";
await WaitIfNecessary();
ReadSuperObjects(reader);
loadingState = "Loading always structure";
await WaitIfNecessary();
ReadAlways(reader);
Pointer.DoAt(ref reader, off_cineManager, () => {
cinematicsManager = CinematicsManager.Read(reader, off_cineManager);
});
// off_current should be after the dynamic SO list positions.
// Parse transformation matrices and other settings(state? :o) for fix characters
loadingState = "Loading settings for persos in fix";
await WaitIfNecessary();
uint num_perso_with_settings_in_fix = (uint)persoInFix.Length;
if (Settings.s.game == Settings.Game.R3)
{
num_perso_with_settings_in_fix = reader.ReadUInt32();
}
for (int i = 0; i < num_perso_with_settings_in_fix; i++)
{
Pointer off_perso_so_with_settings_in_fix = null, off_matrix = null;
SuperObject so = null;
Matrix mat = null;
if (Settings.s.game == Settings.Game.R3)
{
off_perso_so_with_settings_in_fix = Pointer.Read(reader);
off_matrix = Pointer.Current(reader);
mat = Matrix.Read(reader, off_matrix);
reader.ReadUInt32(); // is one of these the state? doesn't appear to change tho
reader.ReadUInt32();
so = SuperObject.FromOffset(off_perso_so_with_settings_in_fix);
}
else if (Settings.s.game == Settings.Game.RA ||
Settings.s.game == Settings.Game.RM ||
Settings.s.game == Settings.Game.Dinosaur)
{
off_matrix = Pointer.Current(reader);
mat = Matrix.Read(reader, off_matrix);
so = superObjects.FirstOrDefault(s => s.off_data == persoInFix[i]);
}
if (so != null)
{
so.off_matrix = off_matrix;
so.matrix = mat;
if (so.Gao != null)
{
so.Gao.transform.localPosition = mat.GetPosition(convertAxes: true);
so.Gao.transform.localRotation = mat.GetRotation(convertAxes: true);
so.Gao.transform.localScale = mat.GetScale(convertAxes: true);
}
}
}
if (Settings.s.platform == Settings.Platform.GC)
{
reader.ReadBytes(0x800); // floats
}
loadingState = "Loading animation banks";
await WaitIfNecessary();
if (Settings.s.game != Settings.Game.Dinosaur)
{
off_animBankLvl = Pointer.Read(reader); // Note: 4 0x104 banks in lvl.
print("Lvl animation bank address: " + off_animBankLvl);
animationBanks = new AnimationBank[5];
if (off_animBankFix != off_animBankLvl)
{
Pointer.DoAt(ref reader, off_animBankFix, () => {
animationBanks[0] = AnimationBank.Read(reader, off_animBankFix, 0, 1, files_array[Mem.FixKeyFrames])[0];
});
}
Pointer.DoAt(ref reader, off_animBankLvl, () => {
AnimationBank[] banks = AnimationBank.Read(reader, off_animBankLvl, 1, 4, files_array[Mem.LvlKeyFrames]);
for (int i = 0; i < 4; i++)
{
animationBanks[1 + i] = banks[i];
}
});
if (off_animBankFix == off_animBankLvl)
{
animationBanks[0] = animationBanks[1];
}
}
// Load additional animation banks
string extraAnimFolder = "Anim/";
if (Settings.s.mode == Settings.Mode.RaymanArenaGCDemo)
{
extraAnimFolder = lvlName + "/";
}
for (int i = 0; i < families.Count; i++)
{
if (families[i] != null && families[i].animBank > 4 && objectTypes[0][families[i].family_index].id != 0xFF)
{
int animBank = families[i].animBank;
loadingState = "Loading additional animation bank " + animBank;
await WaitIfNecessary();
int animFileID = objectTypes[0][families[i].family_index].id;
if (Settings.s.mode == Settings.Mode.RaymanArenaGCDemo)
{
animFileID = animBank - 5;
}
string animName = extraAnimFolder + "ani" + animFileID.ToString();
string kfName = extraAnimFolder + "key" + animFileID.ToString() + "kf";
//print(animBank + " - " + objectTypes[0][families[i].family_index].id);
int fileID = animBank + 102;
int kfFileID = animBank + 2; // Anim bank will start at 5, so this will start at 7
if (Settings.s.game == Settings.Game.RM)
{
fileID = animBank;
}
// Prepare files for WebGL
await PrepareFile(gameDataBinFolder + animName + ".lvl");
if (FileSystem.FileExists(gameDataBinFolder + animName + ".lvl"))
{
await PrepareFile(gameDataBinFolder + animName + ".ptr");
}
await PrepareFile(gameDataBinFolder + kfName + ".lvl");
if (FileSystem.FileExists(gameDataBinFolder + kfName + ".lvl"))
{
await PrepareFile(gameDataBinFolder + kfName + ".ptr");
}
FileWithPointers animFile = InitExtraLVL(animName, fileID);
FileWithPointers kfFile = InitExtraLVL(kfName, fileID);
if (animFile != null)
{
if (animBank >= animationBanks.Length)
{
Array.Resize(ref animationBanks, animBank + 1);
}
Pointer off_animBankExtra = new Pointer(0, animFile);
Pointer.DoAt(ref reader, off_animBankExtra, () => {
int alignBytes = reader.ReadInt32();
if (alignBytes > 0)
{
reader.Align(4, alignBytes);
}
off_animBankExtra = Pointer.Current(reader);
animationBanks[animBank] = AnimationBank.Read(reader, off_animBankExtra, (uint)animBank, 1, kfFile)[0];
});
}
}
}
loadingState = "Filling in cross-references";
await WaitIfNecessary();
ReadCrossReferences(reader);
}
private GeometricObject ConvertMeshSection(Section s)
{
Geometry g = (Geometry)s[0]["geometry"];
uint numMaterials = (uint)s[1][0]["numMaterials"];
uint numUniqueMaterials = (uint)s[1][0]["numUniqueMaterials"];
int[] materialIndices = (int[])s[1][0]["materialIndices"];
Section[] materialSections = new Section[numUniqueMaterials];
VisualMaterial[] materials = new VisualMaterial[numUniqueMaterials];
Array.Copy(s[1].children.ToArray(), 1, materialSections, 0, (int)numUniqueMaterials);
materials = materialSections.Select(vms => ConvertMaterialSection(vms)).ToArray();
//if (numMaterials > 1) MapLoader.Loader.print("NUM MATERIALS " + numMaterials);
GeometricObject m = new GeometricObject(null);
m.num_vertices = (ushort)g.numVertices;
m.normals = g.morphTargets[0].normals;
m.vertices = g.morphTargets[0].vertices;
m.num_elements = (ushort)numMaterials;
m.elements = new IGeometricObjectElement[numMaterials];
uint currentUniqueMaterial = 0;
for (int i = 0; i < numMaterials; i++)
{
GeometricObjectElementTriangles e = new GeometricObjectElementTriangles(null, m);
List <Geometry.Triangle> triangles = new List <Geometry.Triangle>();
for (int j = 0; j < g.numTriangles; j++)
{
if (g.triangles[j].materialId == i)
{
triangles.Add(g.triangles[j]);
}
}
e.OPT_num_mapping_entries = m.num_vertices;
e.num_uvMaps = (ushort)g.numTexSets;
e.OPT_mapping_uvs = new int[e.num_uvMaps][];
e.uvs = new Vector2[0];
e.vertexColors = g.vertexColors;
for (int j = 0; j < g.numTexSets; j++)
{
e.OPT_mapping_uvs[j] = Enumerable.Range(e.num_uvs, m.num_vertices).ToArray();
Array.Resize(ref e.uvs, e.num_uvs + m.num_vertices);
Array.Copy(g.uvs[j], 0, e.uvs, e.num_uvs, m.num_vertices);
e.num_uvs += m.num_vertices;
}
e.OPT_mapping_vertices = Enumerable.Range(0, m.num_vertices).ToArray();
e.OPT_num_disconnectedTriangles = (ushort)triangles.Count;
e.OPT_disconnectedTriangles = new int[triangles.Count * 3];
for (int j = 0; j < triangles.Count; j++)
{
e.OPT_disconnectedTriangles[j * 3] = triangles[j].vertex1;
e.OPT_disconnectedTriangles[j * 3 + 1] = triangles[j].vertex2;
e.OPT_disconnectedTriangles[j * 3 + 2] = triangles[j].vertex3;
}
e.visualMaterial = materialIndices[i] == -1 ? materials[currentUniqueMaterial] : materials[materialIndices[i]];
e.visualMaterialOG = e.visualMaterial;
if (materialIndices[i] == -1)
{
currentUniqueMaterial++;
}
m.elements[i] = e;
}
m.name = "Mesh";
//GameObject gao = m.Gao;
return(m);
}
async Task LoadPS2()
{
await WaitIfNecessary();
textures = new TextureInfo[0];
loadingState = "Loading fixed memory";
await WaitIfNecessary();
files_array[Mem.Fix].GotoHeader();
Reader reader = files_array[Mem.Fix].reader;
Pointer off_base_fix = Pointer.Current(reader);
loadingState = "Loading input struct";
await WaitIfNecessary();
for (int i = 0; i < Settings.s.numEntryActions; i++)
{
Pointer.Read(reader); // 3DOS_EntryActions
}
inputStruct = InputStructure.Read(reader, Pointer.Current(reader));
foreach (EntryAction ea in inputStruct.entryActions)
{
print(ea.ToString());
}
localization = FromOffsetOrRead <LocalizationStructure>(reader, Pointer.Current(reader), inline: true);
/*
* Pointer off_inputStructure = Pointer.Read(reader);
* Pointer.DoAt(ref reader, off_inputStructure, () => {
* inputStruct = InputStructure.Read(reader, off_inputStructure);
* foreach (EntryAction ea in inputStruct.entryActions) {
* print(ea.ToString());
* }
* });*/
/*uint base_language = reader.ReadUInt32(); //Pointer off_language = Pointer.Read(reader);
* reader.ReadUInt32();
* uint num_text_language = reader.ReadUInt32();
* reader.ReadUInt16();
* reader.ReadUInt16();
* reader.ReadUInt32(); // base
* Pointer off_text_general = Pointer.Read(reader);
* Pointer.DoAt(ref reader, off_text_general, () => {
* fontStruct = FontStructure.Read(reader, off_text_general);
* });
* Pointer off_inputStructure = Pointer.Read(reader);
* Pointer.DoAt(ref reader, off_inputStructure, () => {
* inputStruct = InputStructure.Read(reader, off_inputStructure);
* foreach (EntryAction ea in inputStruct.entryActions) {
* print(ea.ToString());
* }
* });
*
* await WaitIfNecessary();
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* Pointer.Read(reader);
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* reader.ReadUInt32();
* Pointer.Read(reader);
* Pointer off_levelNames = Pointer.Read(reader);
* Pointer off_languages = Pointer.Read(reader);
* uint num_levelNames = reader.ReadUInt32();
* uint num_languages = reader.ReadUInt32();
* reader.ReadUInt32(); // same as num_levelNames
* Pointer.DoAt(ref reader, off_levelNames, () => {
* lvlNames = new string[num_levelNames];
* for (uint i = 0; i < num_levelNames; i++) {
* lvlNames[i] = reader.ReadString(0x1E);
* }
* });
* Pointer.DoAt(ref reader, off_languages, () => {
* ReadLanguages(reader, off_languages, num_languages);
* });
* if (languages != null && fontStruct != null) {
* for (int i = 0; i < num_languages; i++) {
* loadingState = "Loading text files: " + (i+1) + "/" + num_languages;
* string langFilePath = gameDataBinFolder + "TEXTS/" + languages[i].ToUpper() + ".LNG";
* await PrepareFile(langFilePath));
* files_array[2] = new DCDAT(languages[i], langFilePath, 2);
* ((DCDAT)files_array[2]).SetHeaderOffset(base_language);
* files_array[2].GotoHeader();
* fontStruct.ReadLanguageTableDreamcast(files_array[2].reader, i, (ushort)num_text_language);
* files_array[2].Dispose();
* }
* }
*
* loadingState = "Loading fixed textures";
* await WaitIfNecessary();
* Pointer off_events_fix = Pointer.Read(reader);
* uint num_events_fix = reader.ReadUInt32();
* uint num_textures_fix = reader.ReadUInt32();
* Pointer off_textures_fix = Pointer.Read(reader);
* Pointer.DoAt(ref reader, off_textures_fix, () => {
* Array.Resize(ref textures, (int)num_textures_fix);
* for (uint i = 0; i < num_textures_fix; i++) {
* Pointer off_texture = Pointer.Read(reader);
* textures[i] = null;
* Pointer.DoAt(ref reader, off_texture, () => {
* textures[i] = TextureInfo.Read(reader, off_texture);
* });
* }
* TEX tex = new TEX(tplPaths[0]);
* for (uint i = 0; i < num_textures_fix; i++) {
* if (textures[i] != null && tex.Count > i) {
* textures[i].Texture = tex.textures[i];
* }
* }
* });*/
loadingState = "Loading level memory";
await WaitIfNecessary();
files_array[Mem.Lvl].GotoHeader();
reader = files_array[Mem.Lvl].reader;
string build = reader.ReadString(0x20);
reader.ReadUInt32();
reader.ReadUInt32(); // 0xc
reader.ReadUInt32(); // 0
Pointer.Read(reader);
Pointer.Read(reader);
// Globals
globals.off_actualWorld = Pointer.Read(reader);
globals.off_dynamicWorld = Pointer.Read(reader);
globals.off_fatherSector = Pointer.Read(reader);
globals.num_always = reader.ReadUInt32();
globals.spawnablePersos = LinkedList <Perso> .ReadHeader(reader, Pointer.Current(reader), LinkedList.Type.Double);
//globals.spawnablePersos.FillPointers(reader, globals.spawnablePersos.off_tail, globals.spawnablePersos.offset);
Pointer.Read(reader); // format: (0x4 number, number * 0x4: null)
globals.off_always_reusableSO = Pointer.Read(reader); // There are (num_always) empty SuperObjects starting with this one.
Pointer.Read(reader);
Pointer.Read(reader);
Pointer.Read(reader);
Pointer.Read(reader);
Pointer.Read(reader);
LinkedList <Perso> cameras = LinkedList <Perso> .ReadHeader(reader, Pointer.Current(reader), LinkedList.Type.Double);
families = LinkedList <Family> .ReadHeader(reader, Pointer.Current(reader), type : LinkedList.Type.Double);
LinkedList <Perso> mainChars = LinkedList <Perso> .ReadHeader(reader, Pointer.Current(reader), LinkedList.Type.Double);
Pointer.Read(reader); // Rayman
reader.ReadUInt32();
globals.off_camera = Pointer.Read(reader); // Camera
Pointer.Read(reader);
Pointer.Read(reader);
Pointer.Read(reader);
uint numMeshes = (uint)files_array[Mem.Lvl].extraData["numMeshes"];
uint numMaterials = (uint)files_array[Mem.Lvl].extraData["numMaterials"];
uint numTextures = (uint)files_array[Mem.Lvl].extraData["numTextures"];
uint numLightmappedObjects = (uint)files_array[Mem.Lvl].extraData["numLightmappedObjects"];
//print("numTextures " + numTextures + " - " + txds[0].Count + " - " + numMeshes + " - " + ato.numAtomics + " - " + numLightmappedObjects);
textures = new TextureInfo[numTextures];
Pointer[] off_meshes = new Pointer[numMeshes];
off_materials = new Pointer[numMaterials];
for (int i = 0; i < numMeshes; i++)
{
off_meshes[i] = Pointer.Read(reader);
}
for (int i = 0; i < numMaterials; i++)
{
off_materials[i] = Pointer.Read(reader);
}
for (int i = 0; i < numTextures; i++)
{
Pointer off_textureInfo = Pointer.Read(reader);
int texture_index = reader.ReadInt32();
Pointer.DoAt(ref reader, off_textureInfo, () => {
textures[i] = TextureInfo.Read(reader, off_textureInfo);
textures[i].Texture = txds[0].Lookup(texture_index.ToString("D3"));
//textures[i].Texture = txds[0].textures[txds[0].Count - 1 - texture_index];
});
}
Pointer.Read(reader);
reader.ReadUInt32();
reader.ReadUInt32();
Pointer.Read(reader);
uint num_unk = reader.ReadUInt32();
for (int i = 0; i < num_unk; i++)
{
Pointer.Read(reader);
}
uint num_unk2 = reader.ReadUInt32();
for (int i = 0; i < num_unk2; i++)
{
Pointer.Read(reader);
}
Pointer.Read(reader);
reader.ReadSingle(); // a bounding volume most likely
reader.ReadSingle();
reader.ReadSingle();
reader.ReadSingle();
reader.ReadSingle();
reader.ReadSingle();
Pointer.Read(reader);
reader.ReadUInt32(); // 2?
uint num_poTable = reader.ReadUInt32();
Pointer off_poTable = Pointer.Read(reader);
reader.ReadUInt32(); // 1. 10x 0
reader.ReadUInt32(); // 2
reader.ReadUInt32(); // 3
reader.ReadUInt32(); // 4
reader.ReadUInt32(); // 5
reader.ReadUInt32(); // 6
reader.ReadUInt32(); // 7
reader.ReadUInt32(); // 8
reader.ReadUInt32(); // 9
reader.ReadUInt32(); // 10
uint num_lightCookies = reader.ReadUInt32();
lightCookieColors = new Color[num_lightCookies];
for (int i = 0; i < num_lightCookies; i++)
{
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
byte b = reader.ReadByte();
byte g = reader.ReadByte();
byte r = reader.ReadByte();
reader.ReadByte();
lightCookieColors[i] = new Color(r / 255f, g / 255f, b / 255f, 1f);
reader.ReadUInt32();
reader.ReadInt32();
reader.ReadUInt32();
}
for (int i = 0; i < num_lightCookies; i++)
{
reader.ReadByte();
}
reader.Align(0x4);
Pointer off_lightCookieMaterial = Pointer.Read(reader);
lightCookieMaterial = VisualMaterial.FromOffsetOrRead(off_lightCookieMaterial, reader);
off_lightmapUV = new Pointer[numLightmappedObjects];
for (int i = 0; i < numLightmappedObjects; i++)
{
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
off_lightmapUV[i] = Pointer.Read(reader);
}
for (int i = 0; i < numMaterials; i++)
{
VisualMaterial.FromOffsetOrRead(off_materials[i], reader);
}
for (int i = 0; i < numMeshes; i++)
{
Pointer.DoAt(ref reader, off_meshes[i], () => {
GeometricObject mesh = GeometricObject.Read(reader, off_meshes[i]);
meshObjects.Add(mesh);
//print("Mesh " + i + ": " + mesh.num_vertices + " - " + mesh.subblock_types[0] + " - " + mesh.num_subblocks);
});
}
loadingState = "Loading families";
await WaitIfNecessary();
ReadFamilies(reader);
//print("Families: " + families.Count);
loadingState = "Loading superobject hierarchy";
await WaitIfNecessary();
ReadSuperObjects(reader);
loadingState = "Loading always structure";
await WaitIfNecessary();
ReadAlways(reader);
loadingState = "Filling in cross-references";
await WaitIfNecessary();
ReadCrossReferences(reader);
await WaitIfNecessary();
}
public GameObject GetGameObject(out GameObject[] boneGaos, GeometricObject morphObject = null, float morphProgress = 0f)
{
GameObject parentGao = new GameObject(Offset.ToString());
// Bones
boneGaos = null;
if (bones != null && bones.Length > 0)
{
GameObject rootBone = new GameObject("Root bone");
boneGaos = new GameObject[] { rootBone };
boneGaos[0].transform.SetParent(parentGao.transform);
boneGaos[0].transform.localPosition = Vector3.zero;
boneGaos[0].transform.localRotation = Quaternion.identity;
boneGaos[0].transform.localScale = Vector3.one;
boneGaos = boneGaos.Concat(bones.Select(b => b.GetGameObject(parentGao))).ToArray();
}
// Morph
Vector3[] mainVertices = vertices.Select(s => new Vector3(
s.x / 256f,
s.z / 256f,
s.y / 256f)).ToArray();
Color[] mainColors = vertices.Select(s => new Color(
s.r / (float)0x80,
s.g / (float)0x80,
s.b / (float)0x80,
1f)).ToArray();
if (morphProgress > 0f && morphObject != null && morphObject.vertices.Length == vertices.Length)
{
Vector3[] morphVertices = morphObject.vertices.Select(s => new Vector3(
s.x / 256f,
s.z / 256f,
s.y / 256f)).ToArray();
Color[] morphColors = morphObject.vertices.Select(s => new Color(
s.r / (float)0x80,
s.g / (float)0x80,
s.b / (float)0x80,
1f)).ToArray();
for (int i = 0; i < vertices.Length; i++)
{
mainVertices[i] = Vector3.Lerp(mainVertices[i], morphVertices[i], morphProgress);
mainColors[i] = Color.Lerp(mainColors[i], morphColors[i], morphProgress);
}
}
// First pass
Dictionary <VisualMaterial, List <IPS1Polygon> > textured = new Dictionary <VisualMaterial, List <IPS1Polygon> >();
List <IPS1Polygon> untextured = new List <IPS1Polygon>();
for (int i = 0; i < triangleLists.Length; i++)
{
PolygonList polys = triangleLists[i];
if (polys.polygons != null)
{
foreach (IPS1Polygon p in polys.polygons)
{
if (p is QuadLOD && (p as QuadLOD).quads?.Length > 0)
{
Quad[] quads = (p as QuadLOD).quads;
foreach (Quad q in quads)
{
VisualMaterial b = q.Material;
if (b == null)
{
untextured.Add(q);
}
else
{
if (!textured.ContainsKey(b))
{
textured[b] = new List <IPS1Polygon>();
}
textured[b].Add(q);
}
}
}
else
{
VisualMaterial b = p.Material;
if (b == null)
{
untextured.Add(p);
}
else
{
if (!textured.ContainsKey(b))
{
textured[b] = new List <IPS1Polygon>();
}
textured[b].Add(p);
}
}
}
}
}
// Second pass
VisualMaterial[] textures = textured.Keys.ToArray();
for (int i = 0; i < textures.Length; i++)
{
VisualMaterial vm = textures[i];
TextureBounds b = vm.texture;
float alpha = 1f;
//if (!vm.IsLight) {
/*switch (vm.BlendMode) {
* case VisualMaterial.SemiTransparentMode.Point25:
* alpha = 0.25f * 4f;
* break;
* case VisualMaterial.SemiTransparentMode.Point5:
* alpha = 0.5f * 4f;
* break;
* }*/
//}
IPS1Polygon pf = textured[vm].FirstOrDefault();
GameObject gao = new GameObject(Offset.ToString()
+ " - " + i
+ " - " + pf?.Offset
+ " - " + pf?.GetType()
+ " - " + string.Format("{0:X2}", vm.materialFlags)
+ "|" + string.Format("{0:X2}", vm.scroll)
+ " - " + vm.BlendMode);
gao.transform.SetParent(parentGao.transform);
gao.layer = LayerMask.NameToLayer("Visual");
gao.transform.localPosition = Vector3.zero;
List <int> vertIndices = new List <int>();
List <int> triIndices = new List <int>();
List <Vector2> uvs = new List <Vector2>();
foreach (IPS1Polygon p in textured[vm])
{
int currentCount = vertIndices.Count;
switch (p)
{
case Triangle t:
vertIndices.Add(t.v0);
vertIndices.Add(t.v1);
vertIndices.Add(t.v2);
uvs.Add(b.CalculateUV(t.x0, t.y0));
uvs.Add(b.CalculateUV(t.x1, t.y1));
uvs.Add(b.CalculateUV(t.x2, t.y2));
/*Vector2 uv0 = b.CalculateUV(t.x0, t.y0);
* Vector2 uv1 = b.CalculateUV(t.x1, t.y1);
* Vector2 uv2 = b.CalculateUV(t.x2, t.y2);
* uvs.Add(uv0);
* uvs.Add(uv1);
* uvs.Add(uv2);*/
triIndices.Add(currentCount);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 2);
break;
case Quad q:
vertIndices.Add(q.v0);
vertIndices.Add(q.v1);
vertIndices.Add(q.v2);
vertIndices.Add(q.v3);
uvs.Add(b.CalculateUV(q.x0, q.y0));
uvs.Add(b.CalculateUV(q.x1, q.y1));
uvs.Add(b.CalculateUV(q.x2, q.y2));
uvs.Add(b.CalculateUV(q.x3, q.y3));
triIndices.Add(currentCount);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 2);
triIndices.Add(currentCount + 2);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 3);
break;
case Sprite s:
GameObject spr_gao = new GameObject("Sprite");
spr_gao.transform.SetParent(gao.transform);
spr_gao.transform.localPosition = mainVertices[s.v0];
BillboardBehaviour billboard = spr_gao.AddComponent <BillboardBehaviour>();
billboard.mode = BillboardBehaviour.LookAtMode.ViewRotation;
MeshFilter sprites_mf = spr_gao.AddComponent <MeshFilter>();
MeshRenderer sprites_mr = spr_gao.AddComponent <MeshRenderer>();
spr_gao.layer = LayerMask.NameToLayer("Visual");
//Material unityMat = sprites[i].visualMaterial.MaterialBillboard;
sprites_mr.receiveShadows = false;
sprites_mr.material = vm.CreateMaterial();
var meshUnity = new Mesh();
Vector3[] vertices = new Vector3[4];
float scale_x = 1.0f;
float scale_y = 1.0f;
scale_x = ((float)s.height / 256f) / 2.0f;
scale_y = ((float)s.width / 256f) / 2.0f;
BoxCollider bc = spr_gao.AddComponent <BoxCollider>();
bc.size = new Vector3(0, scale_y * 2, scale_x * 2);
vertices[0] = new Vector3(0, -scale_y, -scale_x);
vertices[1] = new Vector3(0, -scale_y, scale_x);
vertices[2] = new Vector3(0, scale_y, -scale_x);
vertices[3] = new Vector3(0, scale_y, scale_x);
Vector3[] normals = new Vector3[4];
normals[0] = Vector3.forward;
normals[1] = Vector3.forward;
normals[2] = Vector3.forward;
normals[3] = Vector3.forward;
Vector3[] sprite_uvs = new Vector3[4];
bool mirrorX = false;
bool mirrorY = false;
sprite_uvs[0] = new Vector3(0, 0 - (mirrorY ? 1 : 0), alpha);
sprite_uvs[1] = new Vector3(1 + (mirrorX ? 1 : 0), 0 - (mirrorY ? 1 : 0), alpha);
sprite_uvs[2] = new Vector3(0, 1, alpha);
sprite_uvs[3] = new Vector3(1 + (mirrorX ? 1 : 0), 1, alpha);
int[] triangles = new int[] { 0, 2, 1, 1, 2, 3 };
meshUnity.vertices = vertices;
meshUnity.normals = normals;
meshUnity.triangles = triangles;
meshUnity.SetUVs(0, sprite_uvs.ToList());
sprites_mf.sharedMesh = meshUnity;
break;
}
}
//Vertex[] v = vertIndices.Select(vi => vertices[vi]).ToArray();
BoneWeight[] w = null;
if (bones != null && bones.Length > 0 && boneWeights != null)
{
w = new BoneWeight[vertIndices.Count];
for (int vi = 0; vi < w.Length; vi++)
{
DeformVertexWeights dvw = boneWeights.FirstOrDefault(bw => bw.ind_vertex == vertIndices[vi]);
if (dvw != null)
{
w[vi] = dvw.UnityWeight;
}
else
{
w[vi] = new BoneWeight()
{
boneIndex0 = 0, weight0 = 1f
};
}
}
}
if (vertIndices.Any())
{
MeshFilter mf = gao.AddComponent <MeshFilter>();
gao.AddComponent <ExportableModel>();
MeshRenderer mr = null;
SkinnedMeshRenderer smr = null;
Matrix4x4[] bindPoses = null;
if (bones == null || bones.Length <= 0)
{
mr = gao.AddComponent <MeshRenderer>();
}
else
{
smr = gao.AddComponent <SkinnedMeshRenderer>();
//smr = (SkinnedMeshRenderer)mr;
smr.bones = boneGaos.Select(bo => bo.transform).ToArray();
bindPoses = new Matrix4x4[smr.bones.Length];
for (int bi = 0; bi < smr.bones.Length; bi++)
{
bindPoses[bi] = smr.bones[bi].worldToLocalMatrix * parentGao.transform.localToWorldMatrix;
}
smr.rootBone = smr.bones[0];
}
Mesh m = new Mesh();
m.vertices = vertIndices.Select(vi => mainVertices[vi]).ToArray();
m.colors = vertIndices.Select(vi => mainColors[vi]).ToArray();
m.SetUVs(0, uvs.Select(s => new Vector4(s.x, s.y, alpha, 0f)).ToList());
m.triangles = triIndices.ToArray();
m.RecalculateNormals();
if (w != null)
{
m.boneWeights = w;
m.bindposes = bindPoses;
}
mf.mesh = m;
if (mr != null)
{
mr.material = vm.CreateMaterial();
}
else if (smr != null)
{
smr.material = vm.CreateMaterial();
smr.sharedMesh = m;
}
try {
MeshCollider mc = gao.AddComponent <MeshCollider>();
mc.isTrigger = false;
//mc.cookingOptions = MeshColliderCookingOptions.None;
//mc.sharedMesh = mesh;
} catch (Exception) { }
}
}
// Untextured (some skyboxes, etc)
if (untextured.Count > 0)
{
GameObject gao = new GameObject(Offset.ToString() + " - Untextured");
gao.transform.SetParent(parentGao.transform);
gao.layer = LayerMask.NameToLayer("Visual");
gao.transform.localPosition = Vector3.zero;
MeshFilter mf = gao.AddComponent <MeshFilter>();
gao.AddComponent <ExportableModel>();
MeshRenderer mr = gao.AddComponent <MeshRenderer>();
List <int> vertIndices = new List <int>();
List <int> triIndices = new List <int>();
foreach (IPS1Polygon p in untextured)
{
int currentCount = vertIndices.Count;
switch (p)
{
case TriangleNoTexture t:
vertIndices.Add(t.v0);
vertIndices.Add(t.v1);
vertIndices.Add(t.v2);
triIndices.Add(currentCount);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 2);
break;
case QuadNoTexture q:
vertIndices.Add(q.v0);
vertIndices.Add(q.v1);
vertIndices.Add(q.v2);
vertIndices.Add(q.v3);
triIndices.Add(currentCount);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 2);
triIndices.Add(currentCount + 2);
triIndices.Add(currentCount + 1);
triIndices.Add(currentCount + 3);
break;
default:
Debug.LogWarning(p.GetType()); break;
}
}
//Vertex[] v = vertIndices.Select(vi => vertices[vi]).ToArray();
Mesh m = new Mesh();
m.vertices = vertIndices.Select(vi => mainVertices[vi]).ToArray();
m.colors = vertIndices.Select(vi => mainColors[vi]).ToArray();
m.SetUVs(0, vertIndices.Select(s => new Vector4(0.5f, 0.5f, 1f, 1f)).ToList());
m.triangles = triIndices.ToArray();
m.RecalculateNormals();
mf.mesh = m;
Material baseMaterial;
/*if (m.colors.Any(c => c.a != 1f)) {
* baseMaterial = Load.baseTransparentMaterial;
* } else {*/
baseMaterial = Load.baseMaterial;
//}
Material mat = new Material(baseMaterial);
mat.SetInt("_NumTextures", 1);
string textureName = "_Tex0";
Texture2D tex = Util.GrayTexture();
mat.SetTexture(textureName, tex);
mat.SetVector("_AmbientCoef", Vector4.one);
mat.SetFloat("_Prelit", 1f);
mr.material = mat;
try {
MeshCollider mc = gao.AddComponent <MeshCollider>();
mc.isTrigger = false;
//mc.cookingOptions = MeshColliderCookingOptions.None;
//mc.sharedMesh = mesh;
} catch (Exception) { }
}
return(parentGao);
}
public void Read(Reader reader)
{
offset = Pointer.Current(reader);
switch (type)
{
case DsgVarInfoEntry.DsgVarType.Boolean:
valueBool = reader.ReadBoolean(); break;
case DsgVarInfoEntry.DsgVarType.Byte:
valueByte = reader.ReadSByte(); break;
case DsgVarInfoEntry.DsgVarType.UByte:
valueUByte = reader.ReadByte(); break;
case DsgVarInfoEntry.DsgVarType.Float:
valueFloat = reader.ReadSingle(); break;
case DsgVarInfoEntry.DsgVarType.Int:
valueInt = reader.ReadInt32(); break;
case DsgVarInfoEntry.DsgVarType.UInt:
valueUInt = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.Short:
valueShort = reader.ReadInt16(); break;
case DsgVarInfoEntry.DsgVarType.UShort:
valueUShort = reader.ReadUInt16(); break;
case DsgVarInfoEntry.DsgVarType.Vector:
float x = reader.ReadSingle();
float y = reader.ReadSingle();
float z = reader.ReadSingle();
valueVector = new Vector3(x, y, z);
break;
case DsgVarInfoEntry.DsgVarType.Text:
valueText = reader.ReadInt32(); break;
case DsgVarInfoEntry.DsgVarType.Graph:
valuePointer = Pointer.Read(reader);
valueGraph = Graph.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.WayPoint:
valuePointer = Pointer.Read(reader);
valueWayPoint = WayPoint.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.GameMaterial:
valuePointer = Pointer.Read(reader);
valueGameMaterial = GameMaterial.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.VisualMaterial:
valuePointer = Pointer.Read(reader);
valueVisualMaterial = VisualMaterial.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.ObjectList:
valuePointer = Pointer.Read(reader);
valueObjectList = ObjectList.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.List:
valueList = new List();
valueList.Read(reader);
break;
case DsgVarInfoEntry.DsgVarType.Light:
valuePointer = Pointer.Read(reader);
valueLight = MapLoader.Loader.FromOffsetOrRead <LightInfo>(reader, valuePointer);
break;
case DsgVarInfoEntry.DsgVarType.Comport:
valuePointer = Pointer.Read(reader);
valueComport = MapLoader.Loader.FromOffsetOrRead <Behavior>(reader, valuePointer);
break;
case DsgVarInfoEntry.DsgVarType.Input:
valuePointer = Pointer.Read(reader);
valueInput = EntryAction.FromOffsetOrRead(valuePointer, reader);
break;
// Fill these in after loading
case DsgVarInfoEntry.DsgVarType.Perso:
valuePointer = Pointer.Read(reader);
// Don't fill in perso yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
case DsgVarInfoEntry.DsgVarType.Action:
valuePointer = Pointer.Read(reader);
// Don't fill in state yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
case DsgVarInfoEntry.DsgVarType.SuperObject:
valuePointer = Pointer.Read(reader);
// Don't fill in SO yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
// TODO: Figure these out
case DsgVarInfoEntry.DsgVarType.Caps:
valueCaps = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.SOLinks:
valueSOLinks = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.SoundEvent:
valueSoundEvent = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.Way:
valueWay = reader.ReadUInt32(); break;
// Arrays
case DsgVarInfoEntry.DsgVarType.ActionArray:
case DsgVarInfoEntry.DsgVarType.FloatArray:
case DsgVarInfoEntry.DsgVarType.IntegerArray:
case DsgVarInfoEntry.DsgVarType.PersoArray:
case DsgVarInfoEntry.DsgVarType.SoundEventArray:
case DsgVarInfoEntry.DsgVarType.SuperObjectArray:
case DsgVarInfoEntry.DsgVarType.TextArray:
case DsgVarInfoEntry.DsgVarType.TextRefArray:
case DsgVarInfoEntry.DsgVarType.VectorArray:
case DsgVarInfoEntry.DsgVarType.WayPointArray:
case DsgVarInfoEntry.DsgVarType.GraphArray:
case DsgVarInfoEntry.DsgVarType.Array11:
case DsgVarInfoEntry.DsgVarType.Array9:
ReadArray(reader); break;
}
}
private void UpdateBackground()
{
// Update background color or material
Color? backgroundColor = null;
VisualMaterial skyMaterial = null;
SectorComponent activeBackgroundSector = null;
if (MapLoader.Loader.globals != null && MapLoader.Loader.globals.backgroundGameMaterial != null && MapLoader.Loader.globals.backgroundGameMaterial.visualMaterial != null)
{
skyMaterial = MapLoader.Loader.globals.backgroundGameMaterial.visualMaterial;
}
else
{
if (sectorManager != null && sectorManager.sectors != null && sectorManager.sectors.Count > 0)
{
foreach (SectorComponent s in sectorManager.sectors)
{
if (!s.Loaded)
{
continue;
}
if (s.sector == null)
{
continue;
}
if (s.sector.skyMaterial != null && s.sector.skyMaterial.textures.Count > 0 && s.sector.skyMaterial.textures.Where(t => t.texture != null).Count() > 0)
{
skyMaterial = s.sector.skyMaterial;
activeBackgroundSector = s;
break;
}
else
{
if (!s.Active)
{
continue;
}
foreach (LightInfo li in s.sector.staticLights)
{
if (li.type == 6)
{
backgroundColor = li.background_color;
break;
}
}
}
}
}
}
if (skyMaterial != null && !controller.viewCollision)
{
backgroundPanel.gameObject.SetActive(true);
if (backgroundMaterial != skyMaterial)
{
backgroundMaterial = skyMaterial;
Material skyboxMat = skyMaterial.GetMaterial();
backgroundPanel.sharedMaterial = skyboxMat;
}
//skyboxMat.SetFloat("_DisableLighting", 1f);
backgroundPanel.sharedMaterial.SetFloat("_DisableLightingLocal", 1f);
if (activeBackgroundSector != null)
{
if (activeBackgroundSector != previousActiveBackgroundSector)
{
//backgroundPanel.material.SetFloat("_DisableLightingLocal", 0f);
sectorManager.ApplySectorLighting(activeBackgroundSector, backgroundPanel.gameObject, LightInfo.ObjectLightedFlag.Environment);
previousActiveBackgroundSector = activeBackgroundSector;
}
}
else
{
//backgroundPanel.material.SetFloat("_DisableLighting", 1f);
}
//RenderSettings.skybox = skyboxMat;
//Camera.main.clearFlags = CameraClearFlags.Skybox;
}
else
{
backgroundPanel.gameObject.SetActive(false);
//RenderSettings.skybox = null;
//Camera.main.clearFlags = CameraClearFlags.SolidColor;
}
if (backgroundColor.HasValue && !controller.viewCollision)
{
Camera.main.backgroundColor = backgroundColor.Value;
//Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, backgroundColor.Value, 0.5f * Time.deltaTime);
}
else
{
Camera.main.backgroundColor = Color.black;
//Camera.main.backgroundColor = Color.Lerp(Camera.main.backgroundColor, Color.black, 0.5f * Time.deltaTime);
}
}
