private static void ExportMapSafe(String mapName) { try { String relativePath = FieldMap.GetMapResourcePath(mapName); String outputDirectory = Path.Combine(Configuration.Export.Path, relativePath); String outputPath = outputDirectory + "Atlas.png"; if (File.Exists(outputPath)) { Log.Warning($"[FieldSceneExporter] Export was skipped bacause a file already exists: [{outputPath}]."); return; } Log.Message("[FieldSceneExporter] Exporting [{0}]...", mapName); BGSCENE_DEF scene = new BGSCENE_DEF(true); scene.LoadEBG(null, relativePath, mapName); String directoryPath = Path.GetDirectoryName(outputPath); if (directoryPath != null) { Directory.CreateDirectory(directoryPath); } TextureHelper.WriteTextureToFile(TextureHelper.CopyAsReadable(scene.atlas), outputPath); Log.Message("[FieldSceneExporter] Exporting completed successfully."); } catch (Exception ex) { Log.Error(ex, "[FieldSceneExporter] Failed to export map [{0}].", mapName); } }
private void SetQuad(BGSCENE_DEF scene, Int32 camIdx, Vector2 offset) { Color[] array = new Color[] { Color.cyan, Color.blue, Color.green, Color.yellow, Color.red, Color.white, Color.black, Color.grey }; BGCAM_DEF bgcam_DEF = scene.cameraList[camIdx]; Int32[] array2 = new Int32[] { 2222, -5555, -2222, -5555, -2222, -4080, 2222, -4080 }; Int32[] quad = this.fieldMapData[this.currentQuad].quad; String str = String.Empty; for (Int32 i = 0; i < (Int32)quad.Length; i++) { str = str + ", " + quad[i].ToString(); } Vector3[] array3 = new Vector3[(Int32)quad.Length / 2]; for (Int32 j = 0; j < (Int32)array3.Length; j++) { array3[j] = new Vector3((Single)quad[j * 2], 0f, (Single)quad[j * 2 + 1]); array3[j] = PSX.CalculateGTE_RTPT(array3[j], Matrix4x4.identity, bgcam_DEF.GetMatrixRT(), bgcam_DEF.GetViewDistance(), offset); Color color = array[j]; Single num = 5f; Vector3 b = new Vector3(0f, 0f, (Single)scene.curZ); global::Debug.DrawLine(array3[j] + new Vector3(-num, -num, 0f) + b, array3[j] + new Vector3(num, num, 0f) + b, color, 0f, true); global::Debug.DrawLine(array3[j] + new Vector3(-num, num, 0f) + b, array3[j] + new Vector3(num, -num, 0f) + b, color, 0f, true); } for (Int32 k = 0; k < (Int32)array3.Length; k++) { Int32 num2 = (Int32)array3.Length - 1; Int32 num3 = (Int32)((k - 1 >= 0) ? (k - 1) : num2); Int32 num4 = (Int32)((k + 1 <= num2) ? (k + 1) : 0); Single num5 = Vector3.Angle(array3[k] - array3[num3], array3[k] - array3[num4]); } for (Int32 l = 0; l < (Int32)array3.Length - 1; l++) { global::Debug.DrawLine(array3[l], array3[l + 1], Color.cyan, 0f, true); global::Debug.DrawLine(array3[0], array3[l + 1], Color.cyan, 0f, true); } }
private void _LoadDummyEBG(BGSCENE_DEF sceneUS, String path, String newName, FieldMapLocalizeAreaTitleInfo info, String localizeSymbol) { this.name = newName; TextAsset textAsset = AssetManager.Load <TextAsset>(String.Concat(path, newName, "_", localizeSymbol, ".bgs"), false); if (textAsset == null) { return; } this.ebgBin = textAsset.bytes; using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(this.ebgBin))) { this.ExtractHeaderData(binaryReader); this.ExtractOverlayData(binaryReader); Int32 atlasWidth = info.atlasWidth; Int32 startOvrIdx = info.startOvrIdx; Int32 endOvrIdx = info.endOvrIdx; Int32 spriteStartIndex = info.GetSpriteStartIndex(localizeSymbol); Int32 num = atlasWidth / 36; Int32 num2 = spriteStartIndex; for (Int32 i = startOvrIdx; i <= endOvrIdx; i++) { BGOVERLAY_DEF bGOVERLAY_DEF = this.overlayList[i]; binaryReader.BaseStream.Seek(bGOVERLAY_DEF.prmOffset, SeekOrigin.Begin); for (Int32 j = 0; j < (Int32)bGOVERLAY_DEF.spriteCount; j++) { BGSPRITE_LOC_DEF bGSPRITE_LOC_DEF = new BGSPRITE_LOC_DEF(); bGSPRITE_LOC_DEF.ReadData_BGSPRITE_DEF(binaryReader); bGOVERLAY_DEF.spriteList.Add(bGSPRITE_LOC_DEF); } binaryReader.BaseStream.Seek(bGOVERLAY_DEF.locOffset, SeekOrigin.Begin); for (Int32 k = 0; k < (Int32)bGOVERLAY_DEF.spriteCount; k++) { BGSPRITE_LOC_DEF bGSPRITE_LOC_DEF2 = bGOVERLAY_DEF.spriteList[k]; bGSPRITE_LOC_DEF2.ReadData_BGSPRITELOC_DEF(binaryReader); if (this.useUpscaleFM) { bGSPRITE_LOC_DEF2.atlasX = (UInt16)(2 + num2 % num * 36); bGSPRITE_LOC_DEF2.atlasY = (UInt16)(2 + num2 / num * 36); bGSPRITE_LOC_DEF2.w = 32; bGSPRITE_LOC_DEF2.h = 32; num2++; } } } for (Int32 l = startOvrIdx; l <= endOvrIdx; l++) { sceneUS.overlayList[l] = this.overlayList[l]; } } }
public void SaveFieldMap() { BGSCENE_DEF scene = this.fieldMap.scene; Byte[] ebgBin = scene.ebgBin; String mapName = this.fieldMap.mapName; String fieldMapModName = FieldMapEditor.GetFieldMapModName(mapName); String mapResourcePath = FieldMap.GetMapResourcePath(mapName); using (BinaryWriter binaryWriter = new BinaryWriter(new MemoryStream(ebgBin))) { for (Int32 i = 0; i < (Int32)scene.overlayCount; i++) { BGOVERLAY_DEF bgoverlay_DEF = scene.overlayList[i]; UInt32 oriData = bgoverlay_DEF.oriData; UInt16 num = (UInt16)bgoverlay_DEF.transform.localPosition.z; UInt16 num2 = (UInt16)(oriData >> 8 & 4095u); UInt32 num3 = oriData; UInt32 num4 = 1048320u; num3 &= ~num4; num3 |= (UInt32)((Int64)((Int64)num << 8) & (Int64)((UInt64)num4)); global::Debug.Log(String.Concat(new Object[] { i, " : data :", oriData, ", curZ : ", num, ", oriZ : ", num2, ", res : ", num3 })); binaryWriter.BaseStream.Seek(bgoverlay_DEF.startOffset, SeekOrigin.Begin); binaryWriter.Write(num3); } } String path = "Assets/Resources/" + mapResourcePath + fieldMapModName + ".bgs.bytes"; File.WriteAllBytes(path, ebgBin); }
private static void ExportMapSafe(String mapName) { try { String relativePath = FieldMap.GetMapResourcePath(mapName); String outputDirectory = Path.Combine(Configuration.Export.Path, relativePath); if (Directory.Exists(outputDirectory)) { Log.Warning($"Export was not skipped because kostyli"); //Log.Warning($"[FieldSceneExporter] Export was skipped bacause a directory already exists: [{outputDirectory}]."); //return; } Log.Message("[FieldSceneExporter] Exporting [{0}]...", mapName); BGSCENE_DEF scene = new BGSCENE_DEF(true); scene.LoadEBG(null, relativePath, mapName); //String directoryPath = Path.GetDirectoryName(outputPath); Directory.CreateDirectory(outputDirectory); Texture2D atlasTexture = TextureHelper.CopyAsReadable(scene.atlas); Int32 factor = (Int32)scene.SPRITE_W / 16; Int32 textureWidth = (Int32)(scene.overlayList.SelectMany(s => s.spriteList).Max(s => s.offY * factor) + scene.SPRITE_H); Int32 textureHeight = (Int32)(scene.overlayList.SelectMany(s => s.spriteList).Max(s => s.offX * factor) + scene.SPRITE_W); using (Stream output = File.Create(outputDirectory + "test.psd")) { PsdFile file = new PsdFile(); file.BitDepth = 8; file.ChannelCount = 4; file.ColorMode = PsdColorMode.Rgb; file.RowCount = textureWidth; file.ColumnCount = textureHeight; file.Resolution = new ResolutionInfo { Name = "ResolutionInfo ", HDpi = new UFixed1616(72, 0), HResDisplayUnit = ResolutionInfo.ResUnit.PxPerInch, HeightDisplayUnit = ResolutionInfo.Unit.Centimeters, VDpi = new UFixed1616(72, 0), VResDisplayUnit = ResolutionInfo.ResUnit.PxPerInch, WidthDisplayUnit = ResolutionInfo.Unit.Centimeters }; file.BaseLayer.Name = "Base"; for (Int16 i = 0; i < 4; i++) { Channel channel = new Channel(i, file.BaseLayer); channel.ImageCompression = file.ImageCompression; channel.Length = file.RowCount * Util.BytesPerRow(file.BaseLayer.Rect.Size, file.BitDepth); channel.ImageData = new Byte[channel.Length]; file.BaseLayer.Channels.Add(channel); } file.BaseLayer.Channels.Last().ID = -1; for (Int32 index = scene.overlayList.Count - 1; index >= 0; index--) //scene.overlayList.Count { BGOVERLAY_DEF overlay = scene.overlayList[index]; String outputPath = outputDirectory + $"Overlay{index}.png"; ExportOverlayTest(overlay, atlasTexture, outputPath, scene, file); //return; } file.Save(output, Encoding.UTF8); } //TextureHelper.WriteTextureToFile(TextureHelper.CopyAsReadable(scene.atlas), outputPath); Log.Message("[FieldSceneExporter] Exporting completed successfully."); } catch (Exception ex) { Log.Error(ex, "[FieldSceneExporter] Failed to export map [{0}].", mapName); } }
private static void ExportOverlayTest(BGOVERLAY_DEF overlay, Texture2D atlas, String outputPath, BGSCENE_DEF scene, PsdFile psd) { Int32 factor = (Int32)scene.SPRITE_W / 16; Log.Message($"Transform: {overlay.transform?.name}, Factor: {factor}"); Log.Message($"SPRITE_H: {scene.SPRITE_H:D2} SPRITE_W {scene.SPRITE_W:D2}"); if (overlay.spriteList.Count < 1) { Log.Message("Overlay is empty."); return; } Layer layer = new Layer(psd); psd.Layers.Add(layer); Int32 textureWidth = (Int32)(overlay.spriteList.Max(s => s.offX * factor) + scene.SPRITE_W); Int32 textureHeight = (Int32)(overlay.spriteList.Max(s => s.offY * factor) + scene.SPRITE_H); Texture2D result = new Texture2D(textureWidth, textureHeight, TextureFormat.ARGB32, false); //Log.Message("depth;h;w;u;v;offX;offY;oriData;pad;res;startOffset;texX;texY;trans;localPosition;name"); Channel r = new Channel(0, layer); Channel g = new Channel(1, layer); Channel b = new Channel(2, layer); Channel a = new Channel(-1, layer); layer.Channels.Add(r); layer.Channels.Add(g); layer.Channels.Add(b); layer.Channels.Add(a); Int32 channelSize = textureWidth * textureHeight; r.Length = channelSize; g.Length = channelSize; b.Length = channelSize; a.Length = channelSize; r.ImageData = new Byte[channelSize]; g.ImageData = new Byte[channelSize]; b.ImageData = new Byte[channelSize]; a.ImageData = new Byte[channelSize]; foreach (BGSPRITE_LOC_DEF s in overlay.spriteList) { //Log.Message($"{s.depth};{s.h};{s.w};{s.u};{s.v};{s.offX};{s.offY};{s.oriData};{s.pad};{s.res};{s.startOffset};{s.texX};{s.texY};{s.trans};{s.transform?.localPosition};{s.transform?.name}"); Int32 w = (Int32)scene.SPRITE_W; Int32 h = (Int32)scene.SPRITE_H; Int32 sx = s.atlasX; Int32 sy = (Int32)(scene.ATLAS_H - s.atlasY + 1 * factor - scene.SPRITE_H); Color[] pixels = atlas.GetPixels(sx, sy, w, h); Int32 tx = s.offX * factor; Int32 ty = textureHeight - s.offY * factor; result.SetPixels(tx, ty, w, h, pixels); for (Int32 y = 0; y < h; y++) { for (Int32 x = 0; x < w; x++) { Int32 sourceOffset = (h - y - 1) * w + x; Int32 targetOffset = (s.offY * factor + y) * textureWidth + tx + x; Color color = pixels[sourceOffset]; r.ImageData[targetOffset] = (Byte)(color.r * 255); g.ImageData[targetOffset] = (Byte)(color.g * 255); b.ImageData[targetOffset] = (Byte)(color.b * 255); a.ImageData[targetOffset] = (Byte)(color.a * 255); } } //result.ReadPixels(new Rect(s.atlasX, s.atlasY, scene.SPRITE_W, scene.SPRITE_H), s.offX * factor, textureHeight - s.offY * factor); } TextureHelper.WriteTextureToFile(result, outputPath); layer.Name = Path.GetFileNameWithoutExtension(outputPath); layer.Opacity = 255; layer.Rect = new System.Drawing.Rectangle(overlay.curX * factor, overlay.curY * factor, textureWidth, textureHeight); layer.Masks = new MaskInfo(); layer.BlendingRangesData = new BlendingRanges(layer); layer.CreateMissingChannels(); }
public void LoadEBG(FieldMap fieldMap, String path, String newName) { this.name = newName; if (!this.useUpscaleFM) { this.InitPSXTextureAtlas(); } else { Texture2D x = AssetManager.Load <Texture2D>(Path.Combine(path, "atlas"), false); if (x != null) { this.atlas = x; if (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.WindowsEditor) { this.atlasAlpha = AssetManager.Load <Texture2D>(Path.Combine(path, "atlas_a"), false); } else { this.atlasAlpha = null; } this.SPRITE_W = 32u; this.SPRITE_H = 32u; } else { this.useUpscaleFM = false; this.InitPSXTextureAtlas(); } } if (!this.useUpscaleFM) { this.vram.LoadTIMs(path); } TextAsset textAsset; if (!FieldMapEditor.useOriginalVersion) { textAsset = AssetManager.Load <TextAsset>(path + FieldMapEditor.GetFieldMapModName(newName) + ".bgs", false); if (textAsset == null) { Debug.Log("Cannot find MOD version."); textAsset = AssetManager.Load <TextAsset>(path + newName + ".bgs", false); } } else { textAsset = AssetManager.Load <TextAsset>(path + newName + ".bgs", false); } if (textAsset == null) { return; } this.ebgBin = textAsset.bytes; using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(this.ebgBin))) { this.ReadData(binaryReader); } String symbol = Localization.GetSymbol(); if (symbol != "US") { FieldMapLocalizeAreaTitleInfo info = FieldMapInfo.localizeAreaTitle.GetInfo(newName); if (info != null) { if (symbol != "UK" || info.hasUK) { BGSCENE_DEF bGSCENE_DEF = new BGSCENE_DEF(this.useUpscaleFM); bGSCENE_DEF._LoadDummyEBG(this, path, newName, info, symbol); } } } FieldMapInfo.fieldmapExtraOffset.SetOffset(newName, this.overlayList); if (!this.useUpscaleFM) { this.GenerateAtlasFromBinary(); } this.CreateMaterials(); if (fieldMap != null) { this.CreateScene(fieldMap, this.useUpscaleFM); } }
private static void ExportMapSafe(String mapName) { try { String relativePath = FieldMap.GetMapResourcePath(mapName); String outputDirectory = Path.Combine(Configuration.Export.Path, relativePath); // TODO: uncomment this when all is well //if (Directory.Exists(outputDirectory)) //{ // Log.Warning($"[FieldSceneExporter] Export was skipped bacause a directory already exists: [{outputDirectory}]."); // //return; //} Log.Message("[FieldSceneExporter] Exporting [{0}]...", mapName); BGSCENE_DEF scene = new BGSCENE_DEF(true); scene.LoadResources(null, relativePath, mapName); //String directoryPath = Path.GetDirectoryName(outputPath); Directory.CreateDirectory(outputDirectory); Texture2D atlasTexture = TextureHelper.CopyAsReadable(scene.atlas); Int32 factor = (Int32)scene.SPRITE_W / 16; Int32 textureWidth = (Int32)(scene.overlayList.SelectMany(s => s.spriteList).Max(s => s.offY * factor) + scene.SPRITE_H); Int32 textureHeight = (Int32)(scene.overlayList.SelectMany(s => s.spriteList).Max(s => s.offX * factor) + scene.SPRITE_W); using (Stream output = File.Create(outputDirectory + "test.psd")) { PsdFile file = new PsdFile(); file.BitDepth = 8; file.ChannelCount = 4; file.ColorMode = PsdColorMode.Rgb; file.RowCount = textureWidth; file.ColumnCount = textureHeight; file.Resolution = new ResolutionInfo { Name = "ResolutionInfo ", HDpi = new UFixed1616(72, 0), HResDisplayUnit = ResolutionInfo.ResUnit.PxPerInch, HeightDisplayUnit = ResolutionInfo.Unit.Centimeters, VDpi = new UFixed1616(72, 0), VResDisplayUnit = ResolutionInfo.ResUnit.PxPerInch, WidthDisplayUnit = ResolutionInfo.Unit.Centimeters }; file.BaseLayer.Name = "Base"; for (Int16 i = 0; i < 4; i++) { Channel channel = new Channel(i, file.BaseLayer); channel.ImageCompression = file.ImageCompression; channel.Length = file.RowCount * Util.BytesPerRow(file.BaseLayer.Rect.Size, file.BitDepth); channel.ImageData = new Byte[channel.Length]; file.BaseLayer.Channels.Add(channel); } file.BaseLayer.Channels.Last().ID = -1; for (Int32 index = scene.overlayList.Count - 1; index >= 0; index--) //scene.overlayList.Count { BGOVERLAY_DEF overlay = scene.overlayList[index]; String outputPath = outputDirectory + $"Overlay{index}.png"; ExportOverlay(overlay, atlasTexture, outputPath, scene, file); } // get all languages FieldMapLocalizeAreaTitleInfo info = FieldMapInfo.localizeAreaTitle.GetInfo(mapName); if (info != null) { Int32 startOvrIdx = info.startOvrIdx; Int32 endOvrIdx = info.endOvrIdx; String[] allLanguages = Configuration.Export.Languages; foreach (var language in allLanguages) { BGSCENE_DEF localeScene = new BGSCENE_DEF(scene.GetUseUpscaleFM()); localeScene.LoadLocale(scene, relativePath, mapName, info, language); for (Int32 index = startOvrIdx; index <= endOvrIdx; index++) { BGOVERLAY_DEF overlay = scene.overlayList[index]; String outputPath = outputDirectory + $"Overlay{index}_{language}.png"; ExportOverlay(overlay, atlasTexture, outputPath, scene, file); } } } file.Save(output, Encoding.UTF8); } string strings = $"[PsdSection]\nLayerOrder=name\nReversed = 0"; System.IO.StreamWriter sw = new System.IO.StreamWriter(Path.Combine(outputDirectory, "psd.meta")); sw.WriteLine(strings); sw.Close(); TextureHelper.WriteTextureToFile(atlasTexture, Path.Combine(outputDirectory, "atlas.png")); Log.Message("[FieldSceneExporter] Exporting completed successfully."); } catch (Exception ex) { Log.Error(ex, "[FieldSceneExporter] Failed to export map [{0}].", mapName); } }