378 lines
15 KiB
C#
378 lines
15 KiB
C#
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using SplashEdit.RuntimeCode;
|
|
using Unity.Collections;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
|
|
|
|
namespace SplashEdit.EditorCode
|
|
{
|
|
public class VRAMEditorWindow : EditorWindow
|
|
{
|
|
private int VramWidth => VRAMPacker.VramWidth;
|
|
private int VramHeight => VRAMPacker.VramHeight;
|
|
|
|
private static readonly Vector2 MinSize = new Vector2(800, 600);
|
|
private List<ProhibitedArea> prohibitedAreas = new List<ProhibitedArea>();
|
|
private Vector2 scrollPosition;
|
|
private Texture2D vramImage;
|
|
private Vector2 selectedResolution = new Vector2(320, 240);
|
|
private bool dualBuffering = true;
|
|
private bool verticalLayout = true;
|
|
private Color bufferColor1 = new Color(1, 0, 0, 0.5f);
|
|
private Color bufferColor2 = new Color(0, 1, 0, 0.5f);
|
|
private Color prohibitedColor = new Color(1, 0, 0, 0.3f);
|
|
private PSXData _psxData;
|
|
private PSXFontData[] _cachedFonts;
|
|
|
|
private static readonly Vector2[] resolutions =
|
|
{
|
|
new Vector2(256, 240), new Vector2(256, 480),
|
|
new Vector2(320, 240), new Vector2(320, 480),
|
|
new Vector2(368, 240), new Vector2(368, 480),
|
|
new Vector2(512, 240), new Vector2(512, 480),
|
|
new Vector2(640, 240), new Vector2(640, 480)
|
|
};
|
|
private static string[] resolutionsStrings => resolutions.Select(c => $"{c.x}x{c.y}").ToArray();
|
|
|
|
[MenuItem("PlayStation 1/VRAM Editor")]
|
|
public static void ShowWindow()
|
|
{
|
|
VRAMEditorWindow window = GetWindow<VRAMEditorWindow>("VRAM Editor");
|
|
// Set minimum window dimensions.
|
|
window.minSize = MinSize;
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
// Initialize VRAM texture with black pixels.
|
|
vramImage = new Texture2D(VramWidth, VramHeight);
|
|
NativeArray<Color32> blackPixels = new NativeArray<Color32>(VramWidth * VramHeight, Allocator.Temp);
|
|
vramImage.SetPixelData(blackPixels, 0);
|
|
vramImage.Apply();
|
|
blackPixels.Dispose();
|
|
|
|
// Ensure minimum window size is applied.
|
|
this.minSize = MinSize;
|
|
|
|
_psxData = DataStorage.LoadData(out selectedResolution, out dualBuffering, out verticalLayout, out prohibitedAreas);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pastes an overlay texture onto a base texture at the specified position.
|
|
/// </summary>
|
|
public static void PasteTexture(Texture2D baseTexture, Texture2D overlayTexture, int posX, int posY)
|
|
{
|
|
if (baseTexture == null || overlayTexture == null)
|
|
{
|
|
Debug.LogError("Textures cannot be null!");
|
|
return;
|
|
}
|
|
|
|
Color[] overlayPixels = overlayTexture.GetPixels();
|
|
Color[] basePixels = baseTexture.GetPixels();
|
|
|
|
int baseWidth = baseTexture.width;
|
|
int baseHeight = baseTexture.height;
|
|
int overlayWidth = overlayTexture.width;
|
|
int overlayHeight = overlayTexture.height;
|
|
|
|
// Copy each overlay pixel into the base texture if within bounds.
|
|
for (int y = 0; y < overlayHeight; y++)
|
|
{
|
|
for (int x = 0; x < overlayWidth; x++)
|
|
{
|
|
int baseX = posX + x;
|
|
int baseY = posY + y;
|
|
if (baseX >= 0 && baseX < baseWidth && baseY >= 0 && baseY < baseHeight)
|
|
{
|
|
int baseIndex = baseY * baseWidth + baseX;
|
|
int overlayIndex = y * overlayWidth + x;
|
|
basePixels[baseIndex] = overlayPixels[overlayIndex];
|
|
}
|
|
}
|
|
}
|
|
|
|
baseTexture.SetPixels(basePixels);
|
|
baseTexture.Apply();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Packs PSX textures into VRAM, rebuilds the VRAM texture and writes binary data to an output file.
|
|
/// </summary>
|
|
private void PackTextures()
|
|
{
|
|
// Reinitialize VRAM texture with black pixels.
|
|
vramImage = new Texture2D(VramWidth, VramHeight);
|
|
NativeArray<Color32> blackPixels = new NativeArray<Color32>(VramWidth * VramHeight, Allocator.Temp);
|
|
vramImage.SetPixelData(blackPixels, 0);
|
|
vramImage.Apply();
|
|
blackPixels.Dispose();
|
|
|
|
// Retrieve all PSXObjectExporter objects and create their PSX textures.
|
|
PSXObjectExporter[] objects = FindObjectsByType<PSXObjectExporter>(FindObjectsSortMode.None);
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
|
|
EditorUtility.DisplayProgressBar($"{nameof(VRAMEditorWindow)}", $"Export {nameof(PSXObjectExporter)}", ((float)i) / objects.Length);
|
|
PSXObjectExporter exp = objects[i];
|
|
exp.CreatePSXTextures2D();
|
|
}
|
|
|
|
EditorUtility.ClearProgressBar();
|
|
|
|
// Define framebuffer regions based on selected resolution and layout.
|
|
(Rect buffer1, Rect buffer2) = Utils.BufferForResolution(selectedResolution, verticalLayout);
|
|
|
|
List<Rect> framebuffers = new List<Rect> { buffer1 };
|
|
if (dualBuffering)
|
|
{
|
|
framebuffers.Add(buffer2);
|
|
}
|
|
|
|
// Pack textures into VRAM using the VRAMPacker.
|
|
VRAMPacker tp = new VRAMPacker(framebuffers, prohibitedAreas);
|
|
var packed = tp.PackTexturesIntoVRAM(objects);
|
|
|
|
// Copy packed VRAM pixel data into the texture.
|
|
for (int y = 0; y < VramHeight; y++)
|
|
{
|
|
for (int x = 0; x < VramWidth; x++)
|
|
{
|
|
vramImage.SetPixel(x, VramHeight - y - 1, packed.vramPixels[x, y].GetUnityColor());
|
|
}
|
|
}
|
|
|
|
// Overlay custom font textures into the VRAM preview.
|
|
// Fonts live at x=960 (4bpp = 64 VRAM hwords wide), stacking from y=0.
|
|
PSXFontData[] fonts;
|
|
PSXUIExporter.CollectCanvases(selectedResolution, out fonts);
|
|
_cachedFonts = fonts;
|
|
if (fonts != null && fonts.Length > 0)
|
|
{
|
|
foreach (var font in fonts)
|
|
{
|
|
if (font.PixelData == null || font.PixelData.Length == 0) continue;
|
|
|
|
int vramX = font.VramX;
|
|
int vramY = font.VramY;
|
|
int texH = font.TextureHeight;
|
|
int bytesPerRow = 256 / 2; // 4bpp: 2 pixels per byte, 256 pixels wide = 128 bytes/row
|
|
|
|
// Each byte holds two 4bpp pixels. In VRAM, 4 4bpp pixels = 1 16-bit hword.
|
|
// So 256 4bpp pixels = 64 VRAM hwords.
|
|
for (int y = 0; y < texH && (vramY + y) < VramHeight; y++)
|
|
{
|
|
for (int x = 0; x < 64 && (vramX + x) < VramWidth; x++)
|
|
{
|
|
// Read 4 4bpp pixels from this VRAM hword position
|
|
int byteIdx = y * bytesPerRow + x * 2;
|
|
if (byteIdx + 1 >= font.PixelData.Length) continue;
|
|
byte b0 = font.PixelData[byteIdx];
|
|
byte b1 = font.PixelData[byteIdx + 1];
|
|
// Each byte: low nibble = first pixel, high nibble = second
|
|
// 4 pixels per hword: b0 low, b0 high, b1 low, b1 high
|
|
bool anyOpaque = ((b0 & 0x0F) | (b0 >> 4) | (b1 & 0x0F) | (b1 >> 4)) != 0;
|
|
|
|
if (anyOpaque)
|
|
{
|
|
int px = vramX + x;
|
|
int py = VramHeight - 1 - (vramY + y);
|
|
if (px < VramWidth && py >= 0)
|
|
vramImage.SetPixel(px, py, new Color(0.8f, 0.8f, 1f));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Also show system font area (960, 464)-(1023, 511) = 64x48
|
|
for (int y = 464; y < 512 && y < VramHeight; y++)
|
|
{
|
|
for (int x = 960; x < 1024 && x < VramWidth; x++)
|
|
{
|
|
int py = VramHeight - 1 - y;
|
|
Color existing = vramImage.GetPixel(x, py);
|
|
if (existing.r < 0.01f && existing.g < 0.01f && existing.b < 0.01f)
|
|
vramImage.SetPixel(x, py, new Color(0.3f, 0.3f, 0.5f));
|
|
}
|
|
}
|
|
|
|
vramImage.Apply();
|
|
|
|
// Prompt the user to select a file location and save the VRAM data.
|
|
string path = EditorUtility.SaveFilePanel("Select Output File", "", "output", "bin");
|
|
|
|
if (path != string.Empty)
|
|
{
|
|
using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
|
|
{
|
|
for (int y = 0; y < VramHeight; y++)
|
|
{
|
|
for (int x = 0; x < VramWidth; x++)
|
|
{
|
|
writer.Write(packed.vramPixels[x, y].Pack());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void OnGUI()
|
|
{
|
|
GUILayout.BeginHorizontal();
|
|
GUILayout.BeginVertical();
|
|
GUILayout.Label("VRAM Editor", EditorStyles.boldLabel);
|
|
|
|
// Dropdown for resolution selection.
|
|
selectedResolution = resolutions[EditorGUILayout.Popup("Resolution", System.Array.IndexOf(resolutions, selectedResolution), resolutionsStrings)];
|
|
|
|
// Check resolution constraints for dual buffering.
|
|
bool canDBHorizontal = selectedResolution.x * 2 <= VramWidth;
|
|
bool canDBVertical = selectedResolution.y * 2 <= VramHeight;
|
|
|
|
if (canDBHorizontal || canDBVertical)
|
|
{
|
|
dualBuffering = EditorGUILayout.Toggle("Dual Buffering", dualBuffering);
|
|
}
|
|
else
|
|
{
|
|
dualBuffering = false;
|
|
}
|
|
|
|
if (canDBVertical && canDBHorizontal)
|
|
{
|
|
verticalLayout = EditorGUILayout.Toggle("Vertical", verticalLayout);
|
|
}
|
|
else if (canDBVertical)
|
|
{
|
|
verticalLayout = true;
|
|
}
|
|
else
|
|
{
|
|
verticalLayout = false;
|
|
}
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.Label("Prohibited Areas", EditorStyles.boldLabel);
|
|
GUILayout.Space(10);
|
|
|
|
scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, true, GUILayout.MinHeight(300f), GUILayout.ExpandWidth(true));
|
|
|
|
// List and edit each prohibited area.
|
|
List<int> toRemove = new List<int>();
|
|
|
|
for (int i = 0; i < prohibitedAreas.Count; i++)
|
|
{
|
|
var area = prohibitedAreas[i];
|
|
|
|
GUI.backgroundColor = new Color(0.95f, 0.95f, 0.95f);
|
|
GUILayout.BeginVertical("box");
|
|
|
|
GUI.backgroundColor = Color.white;
|
|
|
|
// Display fields for editing the area
|
|
area.X = EditorGUILayout.IntField("X Coordinate", area.X);
|
|
area.Y = EditorGUILayout.IntField("Y Coordinate", area.Y);
|
|
area.Width = EditorGUILayout.IntField("Width", area.Width);
|
|
area.Height = EditorGUILayout.IntField("Height", area.Height);
|
|
|
|
|
|
if (GUILayout.Button("Remove", GUILayout.Height(30)))
|
|
{
|
|
toRemove.Add(i); // Mark for removal
|
|
}
|
|
|
|
|
|
prohibitedAreas[i] = area;
|
|
|
|
GUILayout.EndVertical();
|
|
GUILayout.Space(10);
|
|
}
|
|
|
|
// Remove the areas marked for deletion outside the loop to avoid skipping elements
|
|
foreach (var index in toRemove.OrderByDescending(x => x))
|
|
{
|
|
prohibitedAreas.RemoveAt(index);
|
|
}
|
|
|
|
GUILayout.EndScrollView();
|
|
GUILayout.Space(10);
|
|
|
|
if (GUILayout.Button("Add Prohibited Area"))
|
|
{
|
|
prohibitedAreas.Add(new ProhibitedArea());
|
|
}
|
|
|
|
// Button to initiate texture packing.
|
|
if (GUILayout.Button("Pack Textures"))
|
|
{
|
|
PackTextures();
|
|
}
|
|
|
|
// Button to save settings; saving now occurs only on button press.
|
|
if (GUILayout.Button("Save Settings"))
|
|
{
|
|
_psxData.OutputResolution = selectedResolution;
|
|
_psxData.DualBuffering = dualBuffering;
|
|
_psxData.VerticalBuffering = verticalLayout;
|
|
_psxData.ProhibitedAreas = prohibitedAreas;
|
|
|
|
DataStorage.StoreData(_psxData);
|
|
EditorUtility.DisplayDialog("splashedit", "Vram configuration saved", "OK");
|
|
}
|
|
|
|
GUILayout.EndVertical();
|
|
|
|
// Display VRAM image preview.
|
|
Rect vramRect = GUILayoutUtility.GetRect(VramWidth, VramHeight, GUILayout.ExpandWidth(false));
|
|
if (vramImage)
|
|
{
|
|
EditorGUI.DrawPreviewTexture(vramRect, vramImage, null, ScaleMode.ScaleToFit, 0, 0, ColorWriteMask.All);
|
|
}
|
|
|
|
// Draw framebuffer overlays.
|
|
(Rect buffer1, Rect buffer2) = Utils.BufferForResolution(selectedResolution, verticalLayout, vramRect.min);
|
|
|
|
EditorGUI.DrawRect(buffer1, bufferColor1);
|
|
GUI.Label(new Rect(buffer1.center.x - 40, buffer1.center.y - 10, 120, 20), "Framebuffer A", EditorStyles.boldLabel);
|
|
GUILayout.Space(10);
|
|
if (dualBuffering)
|
|
{
|
|
EditorGUI.DrawRect(buffer2, bufferColor2);
|
|
GUI.Label(new Rect(buffer2.center.x - 40, buffer2.center.y - 10, 120, 20), "Framebuffer B", EditorStyles.boldLabel);
|
|
}
|
|
|
|
// Draw overlays for each prohibited area.
|
|
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);
|
|
}
|
|
|
|
// Draw font region overlays.
|
|
if (_cachedFonts != null)
|
|
{
|
|
Color fontColor = new Color(0.2f, 0.4f, 0.9f, 0.25f);
|
|
foreach (var font in _cachedFonts)
|
|
{
|
|
if (font.PixelData == null || font.PixelData.Length == 0) continue;
|
|
Rect fontRect = new Rect(vramRect.x + font.VramX, vramRect.y + font.VramY, 64, font.TextureHeight);
|
|
EditorGUI.DrawRect(fontRect, fontColor);
|
|
GUI.Label(new Rect(fontRect.x + 2, fontRect.y + 2, 60, 16), "Font", EditorStyles.miniLabel);
|
|
}
|
|
|
|
// System font overlay
|
|
Rect sysFontRect = new Rect(vramRect.x + 960, vramRect.y + 464, 64, 48);
|
|
EditorGUI.DrawRect(sysFontRect, new Color(0.4f, 0.2f, 0.9f, 0.25f));
|
|
GUI.Label(new Rect(sysFontRect.x + 2, sysFontRect.y + 2, 60, 16), "SysFont", EditorStyles.miniLabel);
|
|
}
|
|
|
|
GUILayout.EndHorizontal();
|
|
}
|
|
}
|
|
} |