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); } }