BlenderSharp/CodeGenerator/Program.cs

// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
using Kaitai;
using System;
using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using Microsoft.CSharp;
using BlendFile = Kaitai.BlenderBlend;

namespace CodeGenerator {
    public class Program {
        public static BlendFile blendfile;
        private static StringBuilder sb = new();
        private const string OutPath = @"Blendfile\DNA";
        private const string Namespace = "BlendFile.DNA";
        private static readonly string[] AdaptedTypes = new[] { "uchar" };

        public static void Log(string message) {
            sb.AppendLine(message);
            Console.WriteLine(message);
        }

        public static void Main(string[] args) {
            Log("Reading blend file");
            ReadBlendFile();

            Log("Generating C# code...");
            
            Log("Pass 1: Generating types");
            CodeNamespace ns = GenerateTypes();
            
            Log("Pass 2: Writing out code");
            OutputCodeFiles(ns);
            
            Log("Finished generating C# code!");
            File.AppendAllText("Log.txt", sb.ToString());
        }

        private static void ReadBlendFile() {
            Log("Reading empty.blend file");
            blendfile = BlendFile.FromFile("empty.blend");

            Log($"Header: Blender v{blendfile.Hdr.Version} {blendfile.Hdr.Endian}\n" +
                $"DataBlocks: {blendfile.Blocks.Count}\n" +
                $"DNA1: {blendfile.SdnaStructs.Count} structures\n");
        }

        private static CodeNamespace GenerateTypes() {
            CodeNamespace ns = new CodeNamespace(Namespace);
            foreach (var type in blendfile.SdnaStructs) {
                Log($"Generating struct {type.Type}");
                bool referenceSelf = false;
                bool referencePointer = false;

                //Create a new type declaration
                var ctd = new CodeTypeDeclaration(type.Type); // { IsStruct = true };

                foreach (var field in type.Fields) {
                    if (field.Name.Contains("*")) {
                        referencePointer = true;
                    }
                    if (field.Type.Contains(type.Type)) {
                        referenceSelf = true;
                    }
                }

                if (referenceSelf || referencePointer) {
                    Log("Struct contains references");
                    ctd.IsClass = true;
                }
                else {
                    ctd.IsStruct = true;
                }

                //Add the class to the namespace
                ns.Types.Add(ctd);

                //Add the fields to the class
                Log($"Fields: {type.Fields.Count}");
                foreach (var field in type.Fields) {
                    CodeMemberField cmf;
                    string name = field.Name;
                    if (field.Name.Contains("[")) {
                        Log($"Generating array field {field.Name}");
                        cmf = CreateArrayMemberField(field);
                    }
                    else {
                        Log($"Generating field {field.Name}");
                        cmf = CreateMemberField(field);
                    }

                    ctd.Members.Add(cmf);
                }

                Log("Generating constructor");
                ctd.Members.Add(GenerateConstructor(type, ctd));

                Log("Finished generating struct");
            }
            return ns;
        }

        private static CodeMemberField CreateMemberField(BlenderBlend.DnaField field) {
            Type t = Type.GetType(field.Type.ParseFType());
            CodeMemberField cmf;
            //Check if the type is a built-in type or a custom type
            if (t != null) cmf = new(t, field.Name.ParseFName()); //Built-in type
            else cmf = new(new CodeTypeReference(field.Type), field.Name.ParseFName()); //Custom type
            cmf.Attributes = MemberAttributes.Public;
            return cmf;
        }

        private static CodeMemberField CreateArrayMemberField(BlenderBlend.DnaField field) {
            Type t = Type.GetType(field.Type.ParseFType());
            CodeMemberField cmf;

            // Parse all array dimensions
            var dimensions = new List<int>();
            var name = field.Name.ParseFName();
            int startIndex = 0;

            // Get all array dimensions
            while ((startIndex = name.IndexOf('[', startIndex)) != -1) {
                int endIndex = name.IndexOf(']', startIndex);
                string sizeStr = name.Substring(startIndex + 1, endIndex - startIndex - 1);
                if (int.TryParse(sizeStr, out int size)) {
                    dimensions.Add(size);
                }
                startIndex = endIndex + 1;
            }

            // Get clean field name (without array brackets)
            name = field.Name.ParseFName().Substring(0, field.Name.IndexOf('['));

            //Check if the type is a built-in type or a custom type
            if (t != null) cmf = new(t, name); //Built-in type
            else cmf = new(field.Type, name); //Custom type

            //Set the field attributes
            cmf.Attributes = MemberAttributes.Public;
            //Define the array type
            cmf.Type.ArrayElementType = new(field.Type.ParseFType() ?? field.Type);
            cmf.Type.ArrayRank = dimensions.Count;

            //Define the array initialization expression
            cmf.InitExpression = GenerateArrayInitExpression(cmf.Type, dimensions);
            return cmf;
        }

        public static CodeExpression GenerateArrayInitExpression(CodeTypeReference type, IEnumerable<int> dimensions) {
            string dims = string.Concat(dimensions.Select(d => $"[{d}]"));
            return new CodeSnippetExpression($"new {type.BaseType}{dims}");
        }
        
        private static CodeTypeConstructor GenerateStaticConstructor(CodeTypeDeclaration ctd) {
            CodeTypeConstructor ctc = new CodeTypeConstructor();
            ctc.Attributes = MemberAttributes.Static;
            ctc.Statements.AddRange(ctd.Members
                .OfType<CodeMemberField>()
                .Where(f => f.Type.ArrayRank > 0)
                .Select(f =>
                {
                    var dims = new List<int>();
                    for (int i = 0; i < f.Type.ArrayRank; i++) {
                        dims.Add(0);
                    }
                    return new CodeAssignStatement(
                        new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), f.Name),
                        GenerateArrayInitExpression(f.Type, dims)
                    );
                }).ToArray<CodeStatement>());
            return ctc;
        }

        private static CodeConstructor GenerateConstructor(BlenderBlend.DnaStruct type, CodeTypeDeclaration ctd) {
            //Create a normal constructor
            CodeConstructor cc = new CodeConstructor {
                Name = type.Type,
                Attributes = MemberAttributes.Public,
                ReturnType = new(type.Type)
            };

            //Add the parameters to the constructor
            cc.Parameters.AddRange(ctd.Members
                .OfType<CodeMemberField>()
                .Select(f =>
                {
                    var cpde = new CodeParameterDeclarationExpression(f.Type, f.Name);
                    cpde.Direction = FieldDirection.In;
                    return cpde;
                }).ToArray());

            //Assign the parameters to the respective fields
            cc.Statements.AddRange(ctd.Members
                .OfType<CodeMemberField>()
                .Select(f => new CodeAssignStatement(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), f.Name),
                    new CodeArgumentReferenceExpression(f.Name))
                ).ToArray<CodeStatement>());

            return cc;
        }
        
        private static void OutputCodeFiles(CodeNamespace ns) {
            CodeNamespace tempNs = new CodeNamespace(Namespace);
            if (!Path.Exists(OutPath)) {
                Directory.CreateDirectory(OutPath);
            }

            CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions() {
                BlankLinesBetweenMembers = false,
                BracingStyle = "Block",
                ElseOnClosing = false,
                IndentString = "    ",
                VerbatimOrder = true
            };
            var provider = new CSharpCodeProvider();
            var date = DateTime.Now.ToString();
            
            CodeNamespace globalNs = new CodeNamespace();
            CodeComment comment = new CodeComment("Automatically generated by BlenderSharp at " + date, false);
            globalNs.Comments.Add(new(comment));
            
            globalNs.Imports.Add(new("System"));
            globalNs.Imports.Add(new("BlendFile.CompatTypes"));
            
            CodeCompileUnit ccu = new CodeCompileUnit();
            ccu.Namespaces.Add(globalNs);
            ccu.Namespaces.Add(tempNs);
            foreach (var type in ns.Types.OfType<CodeTypeDeclaration>()) {
                tempNs.Types.Add(type);
                Log($"Writing out {(type.IsStruct ? "struct" : "class")} {type.Name}");
                using var sw = new StreamWriter($"{OutPath}\\{type.Name}.cs");
                provider.GenerateCodeFromCompileUnit(ccu, sw, codeGeneratorOptions);
                tempNs.Types.Remove(type);
            }
        }
    }
}