Hot reloading preview application for GTA:SA skins

Author: NanoBob

RenderWarePreviewer.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32421.90
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RenderWarePreviewer", "RenderWarePreviewer\RenderWarePreviewer.csproj", "{458151D7-52A5-4318-9FE1-6F5911EFEA05}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{458151D7-52A5-4318-9FE1-6F5911EFEA05}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{458151D7-52A5-4318-9FE1-6F5911EFEA05}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{458151D7-52A5-4318-9FE1-6F5911EFEA05}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{458151D7-52A5-4318-9FE1-6F5911EFEA05}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8118437E-82CA-44D9-B987-EAA0688BCB51}
+	EndGlobalSection
+EndGlobal

RenderWarePreviewer/App.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="RenderWarePreviewer.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:RenderWarePreviewer"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

RenderWarePreviewer/App.xaml.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace RenderWarePreviewer
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}

RenderWarePreviewer/AssemblyInfo.cs

@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+                                     //(used if a resource is not found in the page,
+                                     // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+                                              //(used if a resource is not found in the page,
+                                              // app, or any theme specific resource dictionaries)
+)]

RenderWarePreviewer/Extensions/VectorExtensions.cs

@@ -0,0 +1,14 @@
+using System.Numerics;
+using System.Windows.Media.Media3D;
+
+namespace RenderWarePreviewer.Extensions
+{
+    public static class VectorExtensions
+    {
+        public static Vector3 ToVector3(this Vector3D value) => new Vector3((float)value.X, (float)value.Y, (float)value.Z);
+        public static Vector3D ToVector3D(this Vector3 value) => new Vector3D(value.X, value.Y, value.Z);
+
+        public static Vector3 ToVector3(this Point3D value) => new Vector3((float)value.X, (float)value.Y, (float)value.Z);
+        public static Point3D ToPoint3D(this Vector3 value) => new Point3D(value.X, value.Y, value.Z);
+    }
+}

RenderWarePreviewer/Helpers/AssetHelper.cs

@@ -0,0 +1,135 @@
+using BCnEncoder.Decoder;
+using BCnEncoder.ImageSharp;
+using RenderWareIo;
+using RenderWareIo.Structs.Dff;
+using RenderWareIo.Structs.Ide;
+using RenderWareIo.Structs.Img;
+using RenderWareIo.Structs.Txd;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace RenderWarePreviewer.Helpers
+{
+    public class AssetHelper
+    {
+        private string? gtaPath;
+        private ImgFile? img;
+
+        public AssetHelper()
+        {
+
+        }
+
+        public void SetGtaPath(string path)
+        {
+            var imgPath = Path.Join(path, "models", "gta3.img");
+            if (!File.Exists(imgPath))
+                throw new FileNotFoundException($"No img file found at {path}");
+
+            if (this.img != null)
+                this.img.Dispose();
+
+            this.gtaPath = path;
+            this.img = new ImgFile(imgPath);
+        }
+
+        public Dff GetDff(string name)
+        {
+            if (this.img == null)
+                throw new FileNotFoundException("No img file found");
+
+            var key = SanitizeName(name) + ".dff";
+            if (!this.img.Img.DataEntries.ContainsKey(key))
+                throw new FileNotFoundException($"No {name} file found in txd");
+
+            var data = this.img.Img.DataEntries[key];
+            var stream = GetReadStream(data);
+
+            var dff = new Dff();
+            dff.Read(stream);
+
+            return dff;
+        }
+
+        public Txd GetTxd(string name)
+        {
+            if (this.img == null)
+                throw new FileNotFoundException("No img file found");
+
+            var key = SanitizeName(name) + ".txd";
+            if (!this.img.Img.DataEntries.ContainsKey(key))
+                throw new FileNotFoundException($"No {name} file found in txd");
+
+            var data = this.img.Img.DataEntries[key];
+            var stream = GetReadStream(data);
+
+            var txd = new Txd();
+            txd.Read(stream);
+
+            return txd;
+        }
+
+        public Dictionary<string, Image<Rgba32>> GetImages(Txd txd)
+        {
+            var images = new Dictionary<string, Image<Rgba32>>();
+
+            foreach (var texture in txd.TextureContainer.Textures)
+            {
+                string sanitizedName = SanitizeName(texture.Data.TextureName);
+                string format = texture.Data.TextureFormatString;
+
+                Image<Rgba32> rgbaImage = new(texture.Data.Width, texture.Data.Height);
+
+                switch (format)
+                {
+                    case "RGB32":
+                        {
+                            var image = Image.LoadPixelData<Bgra32>(texture.Data.Data, texture.Data.Width, texture.Data.Height);
+                            rgbaImage = image.CloneAs<Rgba32>();
+                            image.Dispose();
+                            break;
+                        }
+                    case "RGBA32":
+                        {
+                            var image = Image.LoadPixelData<Rgba32>(texture.Data.Data, texture.Data.Width, texture.Data.Height);
+                            rgbaImage = image;
+                            break;
+                        }
+                    case "DXT1":
+                        {
+                            BcDecoder decoder = new();
+                            Image<Rgba32> image = decoder.DecodeRawToImageRgba32(texture.Data.Data, texture.Data.Width, texture.Data.Height, BCnEncoder.Shared.CompressionFormat.Bc1);
+                            rgbaImage = image;
+                            break;
+                        }
+                }
+
+                images[sanitizedName] = rgbaImage;
+            }
+
+            return images;
+        }
+
+        public IEnumerable<Ped> GetSkins()
+        {
+            var ide = new IdeFile(Path.Join(this.gtaPath, "data", "peds.ide"));
+            return ide.Ide.Peds.Where(x => x.Id > 0);
+        }
+
+        public string SanitizeName(string name)
+        {
+            return name.Replace("_", "").Trim('\0').ToLower();
+        }
+
+        private Stream GetReadStream(DataEntry data)
+        {
+            var stream = new MemoryStream();
+            stream.Write(data.Data);
+            stream.Position = 0;
+            return stream;
+        }
+    }
+}

RenderWarePreviewer/Helpers/GtaDirectoryHelper.cs

@@ -0,0 +1,42 @@
+using Microsoft.Win32;
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace RenderWarePreviewer.Helpers
+{
+    public static class GtaDirectoryHelper
+    {
+        private static readonly string configDirectory = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "RenderWarePreviewer");
+        private static readonly string gtaPathFile = Path.Join(configDirectory, "gtapath.txt");
+
+        public static string? GetGtaDirectory()
+        {
+            string? gtaDirectory = GetGtaDirectoryFromFiles();
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && gtaDirectory == null)
+            {
+                using var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\WOW6432Node\Multi Theft Auto: San Andreas All\Common");
+                gtaDirectory = key?.GetValue("GTA:SA Path")?.ToString();
+            }
+
+            return gtaDirectory;
+        }
+
+        private static string? GetGtaDirectoryFromFiles()
+        {
+            if (File.Exists(gtaPathFile))
+                return File.ReadAllText(gtaPathFile);
+
+            return null;
+        }
+
+        public static void StoreGtaDirectory(string path)
+        {
+            if (!Directory.Exists(configDirectory))
+                Directory.CreateDirectory(configDirectory);
+
+            File.WriteAllText(gtaPathFile, path);
+        }
+    }
+}

RenderWarePreviewer/Helpers/MeshHelper.cs

@@ -0,0 +1,139 @@
+using RenderWareIo.Structs.Dff;
+using SixLabors.ImageSharp.PixelFormats;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Media.Media3D;
+
+namespace RenderWarePreviewer.Helpers
+{
+    public static class MeshHelper
+    {
+        private static Dictionary<string, MeshGeometry3D> pyramids = new();
+
+        public static GeometryModel3D GetModel(Dff dff, SixLabors.ImageSharp.Image<Rgba32>? image)
+        {
+            return GetModel(GetMesh(dff), image);
+        }
+
+        public static GeometryModel3D GetModel(MeshGeometry3D mesh, SixLabors.ImageSharp.Image<Rgba32>? image)
+        {
+            return GetModel(mesh, GetMaterial(image));
+        }
+
+        public static GeometryModel3D GetModel(MeshGeometry3D mesh, System.Windows.Media.Media3D.Material material)
+        {
+            return new GeometryModel3D
+            {
+                Geometry = mesh,
+                Material = material
+            };
+        }
+
+        public static GeometryModel3D GetPyramid(System.Windows.Media.Color color, float scale)
+        {
+            var key = $"{color}{scale}";
+            if (pyramids.ContainsKey(key))
+                return GetModel(pyramids[key], GetMaterial(color));
+
+            var mesh = new MeshGeometry3D();
+            foreach (var position in new Point3D[]
+            {
+                new Point3D(-scale, -scale, 0),
+                new Point3D(scale, -scale, 0),
+                new Point3D(scale, scale, 0),
+                new Point3D(-scale, scale, 0),
+                new Point3D(0, 0, scale),
+            })
+                mesh.Positions.Add(position);
+
+            foreach (var triangleIndex in new int[]
+            {
+                0, 1, 2,
+                0, 2, 3,
+                0, 1, 4,
+                1, 2, 4,
+                2, 3, 4,
+                3, 0, 4
+            })
+                mesh.TriangleIndices.Add(triangleIndex);
+
+            foreach (var _ in mesh.Positions)
+                mesh.Normals.Add(new Vector3D(0, 0, 1));
+
+            pyramids[key] = mesh;
+
+            return GetModel(mesh, GetMaterial(color));
+        }
+
+        public static DiffuseMaterial GetMaterial(SixLabors.ImageSharp.Image<Rgba32>? image)
+        {
+            var material = new DiffuseMaterial
+            {
+                Color = System.Windows.Media.Color.FromArgb(255, 255, 255, 255)
+            };
+            if (image != null)
+            {
+                material.Brush = new ImageBrush(GetBitMap(image));
+            }
+            else
+            {
+                material.Brush = new SolidColorBrush(System.Windows.Media.Color.FromArgb(255, 150, 150, 150));
+            }
+            return material;
+        }
+
+        public static DiffuseMaterial GetMaterial(System.Windows.Media.Color color)
+        {
+            var material = new DiffuseMaterial
+            {
+                Color = System.Windows.Media.Color.FromArgb(255, 255, 255, 255),
+                Brush = new SolidColorBrush(color)
+            };
+            return material;
+        }
+
+        public static MeshGeometry3D GetMesh(Dff dff)
+        {
+            var mesh = new MeshGeometry3D();
+            foreach (var vertex in dff.Clump.GeometryList.Geometries.SelectMany(x => x.MorphTargets.SelectMany(y => y.Vertices)))
+            {
+                mesh.Positions.Add(new Point3D(vertex.X, vertex.Y, vertex.Z));
+            }
+
+            foreach (var triangle in dff.Clump.GeometryList.Geometries.SelectMany(x => x.Triangles))
+            {
+                mesh.TriangleIndices.Add(triangle.VertexIndexThree);
+                mesh.TriangleIndices.Add(triangle.VertexIndexTwo);
+                mesh.TriangleIndices.Add(triangle.VertexIndexOne);
+            }
+
+            foreach (var normal in dff.Clump.GeometryList.Geometries.SelectMany(x => x.MorphTargets.SelectMany(y => y.Normals)))
+            {
+                mesh.Normals.Add(new Vector3D(normal.X, normal.Y, normal.Z));
+            }
+
+            foreach (var uv in dff.Clump.GeometryList.Geometries.SelectMany(x => x.TexCoords))
+            {
+                mesh.TextureCoordinates.Add(new Point(uv.X, uv.Y));
+            }
+            return mesh;
+        }
+
+        private static BitmapSource GetBitMap(SixLabors.ImageSharp.Image<Rgba32> image)
+        {
+            Rgba32[] rgbaArray = new Rgba32[image.Width * image.Height];
+            Span<Rgba32> span = new Span<Rgba32>(rgbaArray, 0, rgbaArray.Length);
+            image.CopyPixelDataTo(span);
+            var data = MemoryMarshal.AsBytes(span).ToArray();
+            var bitmap = new RgbaBitmapSource(data, image.Width);
+            //File.WriteAllBytes("output.rgba", data);
+
+            return bitmap;
+        }
+    }
+}