From 00c94d732b68f663b42225efa2a7ac4c7eef7ed7 Mon Sep 17 00:00:00 2001 From: jracek Date: Tue, 11 Mar 2025 12:32:22 +0100 Subject: [PATCH] Texture and clut packing, All important information starts to join in one place for final export --- Editor/PSXObjectExporterEditor.cs | 70 --------- Editor/PSXObjectExporterEditor.cs.meta | 2 - Editor/VramEditorWindow.cs | 120 ++++++++++++++-- Runtime/PSXObjectExporter.cs | 14 +- Runtime/PSXSceneExporter.cs | 2 +- Runtime/PSXTexture2D.cs | 22 +++ Runtime/TexturePacker.cs | 191 +++++++++++++++++++++++++ Runtime/TexturePacker.cs.meta | 2 + 8 files changed, 333 insertions(+), 90 deletions(-) delete mode 100644 Editor/PSXObjectExporterEditor.cs delete mode 100644 Editor/PSXObjectExporterEditor.cs.meta create mode 100644 Runtime/TexturePacker.cs create mode 100644 Runtime/TexturePacker.cs.meta diff --git a/Editor/PSXObjectExporterEditor.cs b/Editor/PSXObjectExporterEditor.cs deleted file mode 100644 index 3508677..0000000 --- a/Editor/PSXObjectExporterEditor.cs +++ /dev/null @@ -1,70 +0,0 @@ -using UnityEngine; -using UnityEditor; -using PSXSplash.RuntimeCode; -using System.IO; - -namespace PSXSplash.EditorCode -{ - - [CustomEditor(typeof(PSXObjectExporter))] - public class PSXObjectExporterEditor : Editor - { - public override void OnInspectorGUI() - { - /* - PSXObjectExporter comp = (PSXObjectExporter)target; - serializedObject.Update(); - - EditorGUILayout.BeginVertical("box"); - EditorGUILayout.PropertyField(serializedObject.FindProperty("Mesh")); - if (GUILayout.Button("Export mesh")) - { - comp.Mesh.Export(comp.gameObject); - GUIUtility.ExitGUI(); - } - EditorGUILayout.EndVertical(); - - - EditorGUILayout.BeginVertical("box"); - EditorGUILayout.PropertyField(serializedObject.FindProperty("Texture")); - if (GUILayout.Button("Export texture")) - { - ushort[] textureData = comp.Texture.ExportTexture(comp.gameObject); - string path = EditorUtility.SaveFilePanel( - "Save texture data", - "", - "texture_data", - "bin" - ); - - if (!string.IsNullOrEmpty(path)) - { - using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write)) - using (BinaryWriter writer = new BinaryWriter(fileStream)) - { - foreach (ushort value in textureData) - { - writer.Write(value); - } - } - Hodně string path = EditorUtility.SaveFilePanel( - "Save clut data", - "", - "clut_data", - "bin" - ); - - if (!string.IsNullOrEmpty(path)) - { - using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write)) - using (BinaryWriter writer = new BinaryWriter(fileStream)) - { - foreach (ushort value in clutData) - { - writer.Write(value); - }Hodně plyModifiedProperties(); - */ - } - - } -} \ No newline at end of file diff --git a/Editor/PSXObjectExporterEditor.cs.meta b/Editor/PSXObjectExporterEditor.cs.meta deleted file mode 100644 index a2dcc29..0000000 --- a/Editor/PSXObjectExporterEditor.cs.meta +++ /dev/null @@ -1,2 +0,0 @@ -fileFormatVersion: 2 -guid: 89b9844e599dd374098ec6168f0de0b0 \ No newline at end of file diff --git a/Editor/VramEditorWindow.cs b/Editor/VramEditorWindow.cs index 31745ff..74119bb 100644 --- a/Editor/VramEditorWindow.cs +++ b/Editor/VramEditorWindow.cs @@ -1,4 +1,6 @@ using System.Collections.Generic; +using System.Linq; +using System.Reflection.Emit; using PSXSplash.RuntimeCode; using Unity.Collections; using UnityEditor; @@ -17,7 +19,6 @@ public class VRAMEditorWindow : EditorWindow private const int VramWidth = 1024; private const int VramHeight = 512; - private VRAMPixel[,] vramPixels = new VRAMPixel[VramWidth, VramHeight]; private List prohibitedAreas = new List(); private Vector2 scrollPosition; private Texture2D vramImage; @@ -44,16 +45,98 @@ public class VRAMEditorWindow : EditorWindow } - - private void OnGUI() + public static void PasteTexture(Texture2D baseTexture, Texture2D overlayTexture, int posX, int posY) { - vramImage = new Texture2D(VramWidth, VramHeight); + if (baseTexture == null || overlayTexture == null) + { + Debug.LogError("Textures cannot be null!"); + return; + } + // Get pixels from the overlay texture + Color[] overlayPixels = overlayTexture.GetPixels(); + Color[] basePixels = baseTexture.GetPixels(); + + int baseWidth = baseTexture.width; + int baseHeight = baseTexture.height; + int overlayWidth = overlayTexture.width; + int overlayHeight = overlayTexture.height; + + // Loop through the overlay texture and paste it onto the base texture + for (int y = 0; y < overlayHeight; y++) + { + for (int x = 0; x < overlayWidth; x++) + { + int baseX = posX + x; + int baseY = posY + y; + + // Ensure we are within bounds of the base texture + if (baseX >= 0 && baseX < baseWidth && baseY >= 0 && baseY < baseHeight) + { + int baseIndex = baseY * baseWidth + baseX; + int overlayIndex = y * overlayWidth + x; + + // Blend or replace pixel (simple overwrite in this case) + basePixels[baseIndex] = overlayPixels[overlayIndex]; + } + } + } + + // Apply the modified pixels back to the base texture + baseTexture.SetPixels(basePixels); + baseTexture.Apply(); + } + + private void PackTextures() + { + + vramImage = new Texture2D(VramWidth, VramHeight); NativeArray blackPixels = new NativeArray(VramWidth * VramHeight, Allocator.Temp); vramImage.SetPixelData(blackPixels, 0); vramImage.Apply(); blackPixels.Dispose(); + PSXObjectExporter[] objects = FindObjectsByType(FindObjectsSortMode.None); + foreach (PSXObjectExporter exp in objects) + { + exp.CreatePSXTexture2D(); + } + + List dontPackAreas = new List(); + foreach (ProhibitedArea area in prohibitedAreas) + { + dontPackAreas.Add(new Rect(area.X, area.Y, area.Width, area.Height)); + } + + Rect buffer1 = new Rect(0, 0, selectedResolution.x, selectedResolution.y); + Rect buffer2 = verticalLayout ? new Rect(0, 256, selectedResolution.x, selectedResolution.y) + : new Rect(selectedResolution.x, 0, selectedResolution.x, selectedResolution.y); + + + dontPackAreas.Add(buffer1); + dontPackAreas.Add(buffer2); + + VRAMPacker tp = new VRAMPacker(dontPackAreas); + var packed = tp.PackTexturesIntoVRAM(objects); + + foreach (TextureAtlas ta in packed.atlases) + { + foreach (PSXTexture2D texture in ta.ContainedTextures) + { + Debug.Log($"Packing {texture} at: x:{ta.PositionX + texture.PackingX} y:{ta.PositionY + texture.PackingY}"); + PasteTexture(vramImage, texture.GenerateVramPreview(), ta.PositionX + texture.PackingX, ta.PositionY + texture.PackingY); + Debug.Log($"Texpage: {texture.TexpageNum} Offset:({texture.PackingX},{texture.PackingY})"); + + for(int i = 0; i < texture.ColorPalette.Count; i++) { + vramImage.SetPixel(texture.ClutPackingX+i, texture.ClutPackingY, texture.ColorPalette[i].GetUnityColor()); + } + vramImage.Apply(); + } + } + } + + private void OnGUI() + { GUILayout.BeginHorizontal(); GUILayout.BeginVertical(); GUILayout.Label("VRAM Editor", EditorStyles.boldLabel); @@ -61,19 +144,22 @@ public class VRAMEditorWindow : EditorWindow selectedResolution = resolutions[EditorGUILayout.Popup("Resolution", System.Array.IndexOf(resolutions, selectedResolution), new string[] { "256x240", "256x480", "320x240", "320x480", "368x240", "368x480", "512x240", "512x480", "640x240", "640x480" })]; - bool canDBHorizontal = selectedResolution[0]*2 <= 1024; - bool canDBVertical = selectedResolution[1]*2 <= 512; + bool canDBHorizontal = selectedResolution[0] * 2 <= 1024; + bool canDBVertical = selectedResolution[1] * 2 <= 512; - if(canDBHorizontal || canDBVertical) { + if (canDBHorizontal || canDBVertical) + { dualBuffering = EditorGUILayout.Toggle("Dual Buffering", dualBuffering); } - else {dualBuffering = false;} - - if(canDBVertical && canDBHorizontal) { + else { dualBuffering = false; } + + if (canDBVertical && canDBHorizontal) + { verticalLayout = EditorGUILayout.Toggle("Vertical", verticalLayout); } - else if (canDBVertical) {verticalLayout = true;} - else { + else if (canDBVertical) { verticalLayout = true; } + else + { verticalLayout = false; } @@ -106,6 +192,13 @@ public class VRAMEditorWindow : EditorWindow { prohibitedAreas.Add(new ProhibitedArea()); } + + // New "Pack Textures" Button + if (GUILayout.Button("Pack Textures")) + { + PackTextures(); + } + GUILayout.EndVertical(); Rect vramRect = GUILayoutUtility.GetRect(VramWidth, VramHeight, GUILayout.ExpandWidth(false)); @@ -124,7 +217,8 @@ public class VRAMEditorWindow : EditorWindow GUI.Label(new Rect(buffer2.center.x - 40, buffer2.center.y - 10, 80, 20), "Framebuffer B", EditorStyles.boldLabel); } - foreach(ProhibitedArea area in prohibitedAreas) { + foreach (ProhibitedArea area in prohibitedAreas) + { Rect areaRect = new Rect(vramRect.x + area.X, vramRect.y + area.Y, area.Width, area.Height); EditorGUI.DrawRect(areaRect, prohibitedColor); } diff --git a/Runtime/PSXObjectExporter.cs b/Runtime/PSXObjectExporter.cs index 181515b..6ccc31a 100644 --- a/Runtime/PSXObjectExporter.cs +++ b/Runtime/PSXObjectExporter.cs @@ -4,13 +4,19 @@ namespace PSXSplash.RuntimeCode { public class PSXObjectExporter : MonoBehaviour { + public PSXBPP BitDepth; - public PSXMesh Mesh; - //ublic PSXTexture Texture; + [HideInInspector] + public PSXTexture2D Texture; - public void Export() + public void CreatePSXTexture2D() { - Debug.Log($"Export: {name}"); + Renderer renderer = GetComponent(); + if (renderer != null && renderer.sharedMaterial != null && renderer.sharedMaterial.mainTexture is Texture2D texture) + { + Texture = PSXTexture2D.CreateFromTexture2D(texture, BitDepth); + Texture.OriginalTexture = texture; + } } } } diff --git a/Runtime/PSXSceneExporter.cs b/Runtime/PSXSceneExporter.cs index f77e9cf..66cfdd2 100644 --- a/Runtime/PSXSceneExporter.cs +++ b/Runtime/PSXSceneExporter.cs @@ -22,7 +22,7 @@ namespace PSXSplash.RuntimeCode if (exporter != null) { - exporter.Export(); + //exporter.Export(); } foreach (Transform child in parentTransform) diff --git a/Runtime/PSXTexture2D.cs b/Runtime/PSXTexture2D.cs index 1f16c8e..9e6cc5d 100644 --- a/Runtime/PSXTexture2D.cs +++ b/Runtime/PSXTexture2D.cs @@ -78,6 +78,10 @@ namespace PSXSplash.RuntimeCode b = (ushort)((packedValue >> 1) & 0b11111); SemiTransparent = (packedValue & 0b1) != 0; } + + public Color GetUnityColor() { + return new Color(R / 31.0f, G / 31.0f, B / 31.0f); + } } /// @@ -86,10 +90,24 @@ namespace PSXSplash.RuntimeCode public class PSXTexture2D { public int Width { get; set; } + public int QuantizedWidth { get; set; } public int Height { get; set; } public int[] PixelIndices { get; set; } public List ColorPalette = new List(); public PSXBPP BitDepth { get; set; } + + public Texture2D OriginalTexture; + + // Within supertexture + public int PackingX; + public int PackingY; + + public int TexpageNum; + + // Absolute positioning + public int ClutPackingX; + public int ClutPackingY; + private int _maxColors; // Used only for 16bpp @@ -106,7 +124,11 @@ namespace PSXSplash.RuntimeCode PSXTexture2D psxTex = new PSXTexture2D(); psxTex.Width = inputTexture.width; + psxTex.QuantizedWidth = bitDepth == PSXBPP.TEX_4BIT ? inputTexture.width / 4 : + bitDepth == PSXBPP.TEX_8BIT ? inputTexture.width / 2 : + inputTexture.width; psxTex.Height = inputTexture.height; + psxTex.BitDepth = bitDepth; diff --git a/Runtime/TexturePacker.cs b/Runtime/TexturePacker.cs new file mode 100644 index 0000000..e84025e --- /dev/null +++ b/Runtime/TexturePacker.cs @@ -0,0 +1,191 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using PSXSplash.RuntimeCode; + +public class TextureAtlas +{ + public PSXBPP BitDepth; + public int PositionX; + public int PositionY; + public int Width; + public const int Height = 256; + public List ContainedTextures = new List(); +} + +public class VRAMPacker +{ + private List _textureAtlases = new List(); + private List _reservedAreas; + private List _finalizedAtlases = new List(); + private List _allocatedCLUTs = new List(); + + private const int VRAM_WIDTH = 1024; + private const int VRAM_HEIGHT = 512; + + public VRAMPacker(List reservedAreas) + { + _reservedAreas = reservedAreas; + } + + public (PSXObjectExporter[] processedObjects, List atlases) PackTexturesIntoVRAM(PSXObjectExporter[] objects) + { + List uniqueTextures = new List(); + var groupedObjects = objects.GroupBy(obj => obj.Texture.BitDepth).OrderByDescending(g => g.Key); + + foreach (var group in groupedObjects) + { + int atlasWidth = group.Key switch + { + PSXBPP.TEX_16BIT => 256, + PSXBPP.TEX_8BIT => 128, + PSXBPP.TEX_4BIT => 64, + _ => 256 + }; + + TextureAtlas atlas = new TextureAtlas { BitDepth = group.Key, Width = atlasWidth, PositionX = 0, PositionY = 0 }; + _textureAtlases.Add(atlas); + + foreach (var obj in group.OrderByDescending(obj => obj.Texture.QuantizedWidth * obj.Texture.Height)) + { + if (uniqueTextures.Any(tex => tex.OriginalTexture.GetInstanceID() == obj.Texture.OriginalTexture.GetInstanceID() && tex.BitDepth == obj.Texture.BitDepth)) + { + obj.Texture = uniqueTextures.First(tex => tex.OriginalTexture.GetInstanceID() == obj.Texture.OriginalTexture.GetInstanceID()); + continue; + } + + if (!TryPlaceTextureInAtlas(atlas, obj.Texture)) + { + atlas = new TextureAtlas { BitDepth = group.Key, Width = atlasWidth, PositionX = 0, PositionY = 0 }; + _textureAtlases.Add(atlas); + if (!TryPlaceTextureInAtlas(atlas, obj.Texture)) + { + Debug.LogError($"Failed to pack texture {obj.Texture}. It might not fit."); + break; + } + } + uniqueTextures.Add(obj.Texture); + } + } + + ArrangeAtlasesInVRAM(); + AllocateCLUTs(); + return (objects, _finalizedAtlases); + } + + private bool TryPlaceTextureInAtlas(TextureAtlas atlas, PSXTexture2D texture) + { + for (int y = 0; y <= TextureAtlas.Height - texture.Height; y++) + { + for (int x = 0; x <= atlas.Width - texture.QuantizedWidth; x++) + { + var candidateRect = new Rect(x, y, texture.QuantizedWidth, texture.Height); + if (!atlas.ContainedTextures.Any(tex => new Rect(tex.PackingX, tex.PackingY, tex.QuantizedWidth, tex.Height).Overlaps(candidateRect))) + { + texture.PackingX = x; + texture.PackingY = y; + atlas.ContainedTextures.Add(texture); + return true; + } + } + } + return false; + } + + private void ArrangeAtlasesInVRAM() + { + foreach (var bitDepth in new[] { PSXBPP.TEX_16BIT, PSXBPP.TEX_8BIT, PSXBPP.TEX_4BIT }) + { + foreach (var atlas in _textureAtlases.Where(a => a.BitDepth == bitDepth)) + { + bool placed = false; + for (int y = VRAM_HEIGHT - TextureAtlas.Height; y >= 0; y -= 256) + { + for (int x = 0; x <= VRAM_WIDTH - atlas.Width; x += 64) + { + if (atlas.PositionX == 0 && atlas.PositionY == 0) + { + var candidateRect = new Rect(x, y, atlas.Width, TextureAtlas.Height); + if (IsPlacementValid(candidateRect)) + { + atlas.PositionX = x; + atlas.PositionY = y; + _finalizedAtlases.Add(atlas); + placed = true; + break; + } + } + } + if (placed) + { + foreach (PSXTexture2D texture in atlas.ContainedTextures) + { + texture.TexpageNum = CalculateTexpage(atlas.PositionX, atlas.PositionY); + } + break; + } + } + if (!placed) + { + Debug.LogError($"Atlas with BitDepth {atlas.BitDepth} and Width {atlas.Width} could not be placed in VRAM."); + } + } + } + } + + private void AllocateCLUTs() + { + foreach (var texture in _finalizedAtlases.SelectMany(atlas => atlas.ContainedTextures)) + { + if (texture.ColorPalette == null || texture.ColorPalette.Count == 0) + continue; + + int clutWidth = texture.ColorPalette.Count; + int clutHeight = 1; + bool placed = false; + + for (int y = 0; y < VRAM_HEIGHT; y++) + { + for (int x = 0; x <= VRAM_WIDTH - clutWidth; x++) + { + var candidate = new Rect(x, y, clutWidth, clutHeight); + if (IsPlacementValid(candidate)) + { + _allocatedCLUTs.Add(candidate); + texture.ClutPackingX = x; + texture.ClutPackingY = y; + placed = true; + break; + } + } + if (placed) break; + } + + if (!placed) + { + Debug.LogError($"Failed to allocate CLUT for texture at {texture.PackingX}, {texture.PackingY}"); + } + } + } + + private bool IsPlacementValid(Rect rect) + { + Rect adjustedRect = new Rect(rect.x, VRAM_HEIGHT - rect.y - rect.height, rect.width, rect.height); + return !_finalizedAtlases.Any(a => AtlasOverlaps(a, rect)) && !_reservedAreas.Any(b => b.Overlaps(adjustedRect)); + } + + private bool AtlasOverlaps(TextureAtlas atlas, Rect rect) + { + Rect atlasRect = new Rect(atlas.PositionX, atlas.PositionY, atlas.Width, TextureAtlas.Height); + return atlasRect.Overlaps(rect); + } + + private int CalculateTexpage(int x, int y) + { + int columns = 16; + int rows = 2; + int colIndex = x / 64; + int rowIndex = (rows - 1) - (y / 256); + return (rowIndex * columns) + colIndex; + } +} diff --git a/Runtime/TexturePacker.cs.meta b/Runtime/TexturePacker.cs.meta new file mode 100644 index 0000000..ed468a6 --- /dev/null +++ b/Runtime/TexturePacker.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: ae72963f3a7f0820cbc31cb4764c51cb \ No newline at end of file