128 lines
4.8 KiB
C#
128 lines
4.8 KiB
C#
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace SplashEdit.RuntimeCode
|
|
{
|
|
[RequireComponent(typeof(Renderer))]
|
|
public class PSXObjectExporter : MonoBehaviour
|
|
{
|
|
public List<PSXTexture2D> Textures { get; set; } = new List<PSXTexture2D>(); // Stores the converted PlayStation-style texture
|
|
public PSXMesh Mesh { get; set; } // Stores the converted PlayStation-style mesh
|
|
[Header("Export Settings")]
|
|
[FormerlySerializedAs("BitDepth")]
|
|
[SerializeField] private PSXBPP bitDepth = PSXBPP.TEX_8BIT; // Defines the bit depth of the texture (e.g., 4BPP, 8BPP)
|
|
[Header("Gizmo Settings")]
|
|
[FormerlySerializedAs("PreviewNormals")]
|
|
[SerializeField] private bool previewNormals = false;
|
|
[SerializeField] private float normalPreviewLength = 0.5f; // Length of the normal lines
|
|
|
|
private readonly Dictionary<(int, PSXBPP), PSXTexture2D> cache = new();
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
if (previewNormals)
|
|
{
|
|
MeshFilter filter = GetComponent<MeshFilter>();
|
|
|
|
if (filter != null)
|
|
{
|
|
Mesh mesh = filter.sharedMesh;
|
|
Vector3[] vertices = mesh.vertices;
|
|
Vector3[] normals = mesh.normals;
|
|
|
|
Gizmos.color = Color.green; // Normal color
|
|
|
|
for (int i = 0; i < vertices.Length; i++)
|
|
{
|
|
Vector3 worldVertex = transform.TransformPoint(vertices[i]); // Convert to world space
|
|
Vector3 worldNormal = transform.TransformDirection(normals[i]); // Transform normal to world space
|
|
|
|
Gizmos.DrawLine(worldVertex, worldVertex + worldNormal * normalPreviewLength);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Converts the object's material texture into a PlayStation-compatible texture.
|
|
/// </summary>
|
|
///
|
|
public void CreatePSXTextures2D()
|
|
{
|
|
Renderer renderer = GetComponent<Renderer>();
|
|
Textures.Clear();
|
|
if (renderer != null)
|
|
{
|
|
Material[] materials = renderer.sharedMaterials;
|
|
|
|
foreach (Material mat in materials)
|
|
{
|
|
if (mat != null && mat.mainTexture != null)
|
|
{
|
|
Texture mainTexture = mat.mainTexture;
|
|
Texture2D tex2D = null;
|
|
|
|
// Check if it's already a Texture2D
|
|
if (mainTexture is Texture2D existingTex2D)
|
|
{
|
|
tex2D = existingTex2D;
|
|
}
|
|
else
|
|
{
|
|
// If not a Texture2D, try to convert
|
|
tex2D = ConvertToTexture2D(mainTexture);
|
|
}
|
|
|
|
if (tex2D != null)
|
|
{
|
|
PSXTexture2D tex;
|
|
if (cache.ContainsKey((tex2D.GetInstanceID(), bitDepth)))
|
|
{
|
|
tex = cache[(tex2D.GetInstanceID(), bitDepth)];
|
|
}
|
|
else
|
|
{
|
|
tex = PSXTexture2D.CreateFromTexture2D(tex2D, bitDepth);
|
|
tex.OriginalTexture = tex2D; // Store reference to the original texture
|
|
cache.Add((tex2D.GetInstanceID(), bitDepth), tex);
|
|
}
|
|
Textures.Add(tex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Texture2D ConvertToTexture2D(Texture texture)
|
|
{
|
|
// Create a new Texture2D with the same dimensions and format
|
|
Texture2D texture2D = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
|
|
|
|
// Read the texture pixels
|
|
RenderTexture currentActiveRT = RenderTexture.active;
|
|
RenderTexture.active = texture as RenderTexture;
|
|
|
|
texture2D.ReadPixels(new Rect(0, 0, texture.width, texture.height), 0, 0);
|
|
texture2D.Apply();
|
|
|
|
RenderTexture.active = currentActiveRT;
|
|
|
|
return texture2D;
|
|
}
|
|
/// <summary>
|
|
/// Converts the object's mesh into a PlayStation-compatible mesh.
|
|
/// </summary>
|
|
public void CreatePSXMesh(float GTEScaling)
|
|
{
|
|
Renderer renderer = GetComponent<Renderer>();
|
|
if (renderer != null)
|
|
{
|
|
Mesh = PSXMesh.CreateFromUnityRenderer(renderer, GTEScaling, transform, Textures);
|
|
}
|
|
}
|
|
}
|
|
}
|