feature: Added psxsplash installer, added basic BSP implementation (non-functional)

Runtime/PSXObjectExporter.cs

@@ -12,19 +12,30 @@ namespace SplashEdit.RuntimeCode
 
         public bool IsActive = true;
 
-        public List<PSXTexture2D> Textures { get; set; } = new List<PSXTexture2D>(); // Stores the converted PlayStation-style texture
-        public PSXMesh Mesh { get; protected set; } // Stores the converted PlayStation-style mesh
+        public List<PSXTexture2D> Textures { get; set; } = new List<PSXTexture2D>();
+        public PSXMesh Mesh { get; protected set; }
+        
         [Header("Export Settings")]
         [FormerlySerializedAs("BitDepth")]
-        [SerializeField] private PSXBPP bitDepth = PSXBPP.TEX_8BIT; // Defines the bit depth of the texture (e.g., 4BPP, 8BPP)
+        [SerializeField] private PSXBPP bitDepth = PSXBPP.TEX_8BIT;
         [SerializeField] private LuaFile luaFile;
+        
+        [Header("BSP Settings")]
+        [SerializeField] private Mesh _modifiedMesh; // Mesh after BSP processing
+        
         [Header("Gizmo Settings")]
         [FormerlySerializedAs("PreviewNormals")]
         [SerializeField] private bool previewNormals = false;
-        [SerializeField] private float normalPreviewLength = 0.5f; // Length of the normal lines
+        [SerializeField] private float normalPreviewLength = 0.5f;
 
         private readonly Dictionary<(int, PSXBPP), PSXTexture2D> cache = new();
 
+        public Mesh ModifiedMesh 
+        {
+            get => _modifiedMesh;
+            set => _modifiedMesh = value;
+        }
+
         private void OnDrawGizmos()
         {
             if (previewNormals)
@@ -37,25 +48,19 @@ namespace SplashEdit.RuntimeCode
                     Vector3[] vertices = mesh.vertices;
                     Vector3[] normals = mesh.normals;
 
-                    Gizmos.color = Color.green; // Normal color
+                    Gizmos.color = Color.green;
 
                     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
+                        Vector3 worldVertex = transform.TransformPoint(vertices[i]);
+                        Vector3 worldNormal = transform.TransformDirection(normals[i]);
 
                         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>();
@@ -71,14 +76,12 @@ namespace SplashEdit.RuntimeCode
                         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);
                         }
 
@@ -92,7 +95,7 @@ namespace SplashEdit.RuntimeCode
                             else
                             {
                                 tex = PSXTexture2D.CreateFromTexture2D(tex2D, bitDepth);
-                                tex.OriginalTexture = tex2D; // Store reference to the original texture
+                                tex.OriginalTexture = tex2D;
                                 cache.Add((tex2D.GetInstanceID(), bitDepth), tex);
                             }
                             Textures.Add(tex);
@@ -104,10 +107,8 @@ namespace SplashEdit.RuntimeCode
 
         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;
 
@@ -128,16 +129,35 @@ namespace SplashEdit.RuntimeCode
             return null;
         }
 
-        /// <summary>
-        /// Converts the object's mesh into a PlayStation-compatible mesh.
-        /// </summary>
-        public void CreatePSXMesh(float GTEScaling)
+        public void CreatePSXMesh(float GTEScaling, bool useBSP = false)
         {
             Renderer renderer = GetComponent<Renderer>();
             if (renderer != null)
             {
-                Mesh = PSXMesh.CreateFromUnityRenderer(renderer, GTEScaling, transform, Textures);
+                if (useBSP && _modifiedMesh != null)
+                {
+                    // Create a temporary GameObject with the modified mesh but same materials
+                    GameObject tempGO = new GameObject("TempBSPMesh");
+                    tempGO.transform.position = transform.position;
+                    tempGO.transform.rotation = transform.rotation;
+                    tempGO.transform.localScale = transform.localScale;
+                    
+                    MeshFilter tempMF = tempGO.AddComponent<MeshFilter>();
+                    tempMF.sharedMesh = _modifiedMesh;
+                    
+                    MeshRenderer tempMR = tempGO.AddComponent<MeshRenderer>();
+                    tempMR.sharedMaterials = renderer.sharedMaterials;
+                    
+                    Mesh = PSXMesh.CreateFromUnityRenderer(tempMR, GTEScaling, transform, Textures);
+                    
+                    // Clean up
+                    GameObject.DestroyImmediate(tempGO);
+                }
+                else
+                {
+                    Mesh = PSXMesh.CreateFromUnityRenderer(renderer, GTEScaling, transform, Textures);
+                }
             }
         }
     }
-}
+}