jracek/secretsplash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

psst

Browse Source
This commit is contained in:
Jan Racek
2026-03-24 13:00:54 +01:00
parent 53e993f58e
commit 4aa4e49424
145 changed files with 10853 additions and 2965 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
Runtime/PSXMesh.cs
View File

@@ -28,8 +28,17 @@ namespace SplashEdit.RuntimeCode
public PSXVertex v1;
public PSXVertex v2;
/// <summary>
/// Index into the texture list for this triangle's material.
/// -1 means untextured (vertex-color only, rendered as POLY_G3).
/// </summary>
public int TextureIndex;
public readonly PSXVertex[] Vertexes => new PSXVertex[] { v0, v1, v2 };
/// <summary>
/// Whether this triangle is untextured (vertex-color only).
/// Untextured triangles are rendered as GouraudTriangle (POLY_G3) on PS1.
/// </summary>
public bool IsUntextured => TextureIndex == -1;
}
/// <summary>
@@ -77,121 +86,56 @@ namespace SplashEdit.RuntimeCode
/// <summary>
/// Creates a PSXMesh from a Unity Mesh by converting its vertices, normals, UVs, and applying shading.
/// </summary>
/// <param name="mesh">The Unity mesh to convert.</param>
/// <param name="textureWidth">Width of the texture (default is 256).</param>
/// <param name="textureHeight">Height of the texture (default is 256).</param>
/// <param name="transform">Optional transform to convert vertices to world space.</param>
/// <returns>A new PSXMesh containing the converted triangles.</returns>
/// <summary>
/// Creates a PSXMesh from a Unity Renderer by extracting its mesh and materials.
/// </summary>
public static PSXMesh CreateFromUnityRenderer(Renderer renderer, float GTEScaling, Transform transform, List<PSXTexture2D> textures)
{
PSXMesh psxMesh = new PSXMesh { Triangles = new List<Tri>() };
Material[] materials = renderer.sharedMaterials;
Mesh mesh = renderer.GetComponent<MeshFilter>().sharedMesh;
for (int submeshIndex = 0; submeshIndex < materials.Length; submeshIndex++)
{
int[] submeshTriangles = mesh.GetTriangles(submeshIndex);
Material material = materials[submeshIndex];
Texture2D texture = material.mainTexture as Texture2D;
// Find texture index instead of the texture itself
int textureIndex = -1;
if (texture != null)
{
for (int i = 0; i < textures.Count; i++)
{
if (textures[i].OriginalTexture == texture)
{
textureIndex = i;
break;
}
}
}
if (textureIndex == -1)
{
continue;
}
// Get mesh data arrays
mesh.RecalculateNormals();
Vector3[] vertices = mesh.vertices;
Vector3[] normals = mesh.normals;
Vector3[] smoothNormals = RecalculateSmoothNormals(mesh);
Vector2[] uv = mesh.uv;
PSXVertex convertData(int index)
{
Vector3 v = Vector3.Scale(vertices[index], transform.lossyScale);
Vector3 wv = transform.TransformPoint(vertices[index]);
Vector3 wn = transform.TransformDirection(smoothNormals[index]).normalized;
Color c = PSXLightingBaker.ComputeLighting(wv, wn);
return ConvertToPSXVertex(v, GTEScaling, normals[index], uv[index], textures[textureIndex]?.Width, textures[textureIndex]?.Height, c);
}
for (int i = 0; i < submeshTriangles.Length; i += 3)
{
int vid0 = submeshTriangles[i];
int vid1 = submeshTriangles[i + 1];
int vid2 = submeshTriangles[i + 2];
Vector3 faceNormal = Vector3.Cross(vertices[vid1] - vertices[vid0], vertices[vid2] - vertices[vid0]).normalized;
if (Vector3.Dot(faceNormal, normals[vid0]) < 0)
{
(vid1, vid2) = (vid2, vid1);
}
psxMesh.Triangles.Add(new Tri
{
v0 = convertData(vid0),
v1 = convertData(vid1),
v2 = convertData(vid2),
TextureIndex = textureIndex
});
}
}
return psxMesh;
return BuildFromMesh(mesh, renderer, GTEScaling, transform, textures);
}
/// <summary>
/// Creates a PSXMesh from a supplied Unity Mesh with the renderer's materials.
/// </summary>
public static PSXMesh CreateFromUnityMesh(Mesh mesh, Renderer renderer, float GTEScaling, Transform transform, List<PSXTexture2D> textures)
{
return BuildFromMesh(mesh, renderer, GTEScaling, transform, textures);
}
private static PSXMesh BuildFromMesh(Mesh mesh, Renderer renderer, float GTEScaling, Transform transform, List<PSXTexture2D> textures)
{
PSXMesh psxMesh = new PSXMesh { Triangles = new List<Tri>() };
Material[] materials = renderer.sharedMaterials;
// Ensure mesh has required data
// Guard: only recalculate normals if missing
if (mesh.normals == null || mesh.normals.Length == 0)
{
mesh.RecalculateNormals();
}
if (mesh.uv == null || mesh.uv.Length == 0)
{
Vector2[] uvs = new Vector2[mesh.vertices.Length];
mesh.uv = uvs;
}
mesh.uv = new Vector2[mesh.vertices.Length];
// Precompute smooth normals for the entire mesh
Vector3[] smoothNormals = RecalculateSmoothNormals(mesh);
// Cache lights once for the entire mesh
Light[] sceneLights = Object.FindObjectsByType<Light>(FindObjectsSortMode.None)
.Where(l => l.enabled).ToArray();
// Precompute world positions and normals for all vertices
Vector3[] worldVertices = new Vector3[mesh.vertices.Length];
Vector3[] worldNormals = new Vector3[mesh.normals.Length];
for (int i = 0; i < mesh.vertices.Length; i++)
{
worldVertices[i] = transform.TransformPoint(mesh.vertices[i]);
worldNormals[i] = transform.TransformDirection(mesh.normals[i]).normalized;
worldNormals[i] = transform.TransformDirection(smoothNormals[i]).normalized;
}
for (int submeshIndex = 0; submeshIndex < mesh.subMeshCount; submeshIndex++)
{
int materialIndex = Mathf.Min(submeshIndex, materials.Length - 1);
Material material = materials[materialIndex];
Texture2D texture = material.mainTexture as Texture2D;
Texture2D texture = material != null ? material.mainTexture as Texture2D : null;
// Find texture index
int textureIndex = -1;
if (texture != null)
{
@@ -206,8 +150,6 @@ namespace SplashEdit.RuntimeCode
}
int[] submeshTriangles = mesh.GetTriangles(submeshIndex);
// Get mesh data arrays
Vector3[] vertices = mesh.vertices;
Vector3[] normals = mesh.normals;
Vector2[] uv = mesh.uv;
@@ -215,16 +157,20 @@ namespace SplashEdit.RuntimeCode
PSXVertex convertData(int index)
{
Vector3 v = Vector3.Scale(vertices[index], transform.lossyScale);
// Use precomputed world position and normal for consistent lighting
Vector3 wv = worldVertices[index];
Vector3 wn = worldNormals[index];
Color c = PSXLightingBaker.ComputeLighting(wv, wn, sceneLights);
// For split triangles, use the original vertex's lighting if possible
Color c = PSXLightingBaker.ComputeLighting(wv, wn);
if (textureIndex == -1)
{
Color matColor = material != null && material.HasProperty("_Color")
? material.color : Color.white;
c = new Color(c.r * matColor.r, c.g * matColor.g, c.b * matColor.b);
return ConvertToPSXVertex(v, GTEScaling, normals[index], Vector2.zero, null, null, c);
}
return ConvertToPSXVertex(v, GTEScaling, normals[index], uv[index],
textures[textureIndex]?.Width, textures[textureIndex]?.Height, c);
textures[textureIndex]?.Width, textures[textureIndex]?.Height, c);
}
for (int i = 0; i < submeshTriangles.Length; i += 3)