Include clang-format document

.clang-format

@@ -0,0 +1,209 @@
+TabWidth: 4
+IndentWidth: 4
+ColumnLimit: 80
+
+UseTab: AlignWithSpaces
+
+# Pointer and reference alignment style. Possible values: Left, Right, Middle.
+PointerAlignment: Right
+
+# AccessModifierOffset (int)
+# The extra indent or outdent of access modifiers, e.g. public:.
+AccessModifierOffset: 0
+
+AlignArrayOfStructures: Right
+AlignAfterOpenBracket: true
+AlignConsecutiveAssignments: Consecutive
+AlignConsecutiveBitFields: Consecutive
+AlignConsecutiveDeclarations: None
+AlignConsecutiveMacros: Consecutive
+AlignConsecutiveShortCaseStatements:
+    Enabled: true
+    AcrossEmptyLines: true
+    AcrossComments: true
+    AlignCaseColons: false
+
+
+AlignEscapedNewlines: LeftWithLastLine
+
+AlignOperands: Align
+
+AlignTrailingComments:
+    Kind: Always
+    AlignPPAndNotPP: true
+
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Always
+
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: false
+
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: Inline
+AllowShortLoopsOnASingleLine: true
+AllowShortNamespacesOnASingleLine: false
+
+AlwaysBreakBeforeMultilineStrings: false
+
+BitFieldColonSpacing: Both
+
+# TODO Highly Opinionated will need to deliberate on this. I prefer K&R Style but some prefer Allman
+BreakBeforeBraces: Custom
+BraceWrapping:
+    AfterCaseLabel: false
+    AfterClass: false
+    AfterControlStatement: Never
+    AfterEnum: false
+    AfterFunction: false
+    AfterNamespace: false
+    AfterStruct: false
+    AfterExternBlock: false
+    BeforeCatch: true # catch on separate line, not like we'll use catch
+    BeforeElse: true
+    BeforeLambdaBody: false
+    BeforeWhile: true
+    IndentBraces: false
+
+BreakAdjacentStringLiterals: false
+BreakAfterAttributes: Leave
+
+BreakAfterOpenBracketBracedList: false
+BreakAfterOpenBracketFunction: false
+BreakAfterOpenBracketIf: false
+BreakAfterOpenBracketLoop: false
+BreakAfterOpenBracketSwitch: false
+BreakAfterReturnType: Automatic
+
+BreakBeforeBinaryOperators: None
+BreakBeforeCloseBracketBracedList: true
+BreakBeforeCloseBracketFunction: true
+BreakBeforeCloseBracketIf: true
+BreakBeforeCloseBracketSwitch: true
+
+BreakBeforeConceptDeclarations: Allowed
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: true
+BreakBeforeTernaryOperators: true
+
+BreakConstructorInitializers: AfterColon
+BreakFunctionDefinitionParameters: false
+
+BreakInheritanceList: AfterColon
+
+BreakStringLiterals: false
+
+BreakTemplateDeclarations: Leave
+
+CompactNamespaces: false
+
+Cpp11BracedListStyle: FunctionCall
+
+EmptyLineAfterAccessModifier: Leave
+EmptyLineBeforeAccessModifier: LogicalBlock
+
+EnumTrailingComma: Leave
+
+FixNamespaceComments: true
+
+IndentAccessModifiers: false
+
+IndentCaseBlocks: false
+
+IndentExportBlock: false
+IndentExternBlock: false
+IndentGotoLabels: true
+
+IndentPPDirectives: BeforeHash
+IndentRequiresClause: false
+IndentWrappedFunctionNames: false
+
+# I personally don't like unbraced things but this should be heavily discussed
+# For example it's a Pain in the ass to go back and add braces when someone
+# didn't include them after you need to extend it
+InsertBraces: true
+
+InsertNewlineAtEOF: true
+
+# This one will be controversial...
+IntegerLiteralSeparator:
+    Binary: 4
+    Decimal: 3
+    Hex: 4
+    BinaryMinDigitsInsert: 8
+    DecimalMinDigitsInsert: 6
+    HexMinDigitsInsert: 8
+
+KeepEmptyLines:
+    AtEndOfFile: false
+    AtStartOfBlock: false
+    AtStartOfFile: false
+
+KeepFormFeed: false
+
+# No Microslop BS \r\n 
+LineEnding: LF
+
+NamespaceIndentation: None
+
+NumericLiteralCase:
+    ExponentLetter: Leave
+    HexDigit: Lower
+    Prefix: Lower
+    Suffix: Upper
+
+# TODO Use after upgrading to Clang 23
+# PackParameters:
+#     BinPack: OnePerLine
+
+BinPackParameters: OnePerLine
+
+QualifierAlignment: Right
+
+ReflowComments: Never
+
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+
+RemoveSemicolon: false
+
+RequiresExpressionIndentation: OuterScope
+
+SeparateDefinitionBlocks: Leave
+
+SkipMacroDefinitionBody: true
+
+SortIncludes:
+    Enabled: false
+
+SortUsingDeclarations: Never
+
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
+SpaceAfterTemplateKeyword: false
+SpaceAroundPointerQualifiers: Default
+
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBraces: Always
+
+SpacesInAngles: Leave
+
+SpacesInContainerLiterals: false
+SpacesInParens: Never
+SpacesInSquareBrackets: false
+
+

.clang-format-ignore

@@ -0,0 +1,2 @@
+build/*
+engine/native/thirdparty/*

engine/native/core/definitions/definitions.cppm

@@ -6,24 +6,22 @@ export module core.defs;
 export import core.version;
 export import core.stdtypes;
 
-static_assert(__cplusplus >=  202207L, "Minimum of C++23 required. Consider upgrading your compiler.");
+static_assert(__cplusplus >= 202'207L,
+              "Minimum of C++23 required. Consider upgrading your compiler.");
 
 export namespace draco {
-    template<typename T>
-    concept arithmetic = std::is_arithmetic_v<T>;
+template<typename T> concept arithmetic = std::is_arithmetic_v<T>;
 
-    template<typename T>
-    concept trivial = std::is_trivial_v<T>;
+template<typename T> concept trivial = std::is_trivial_v<T>;
 
-    // Whether the default value of a type is just all-0 bytes.
-    // This can most commonly be exploited by using memset for these types instead of loop-construct.
-    // Must be explicitly specialized to mark a type as such.
-    template <typename T>
-    struct is_zero_constructible : std::false_type {};
+// Whether the default value of a type is just all-0 bytes.
+// This can most commonly be exploited by using memset for these types instead of loop-construct.
+// Must be explicitly specialized to mark a type as such.
+template<typename T>
+struct is_zero_constructible : std::false_type { };
 
-    template <typename T>
-    constexpr bool is_zero_constructible_v = is_zero_constructible<T>::value;
+template<typename T>
+constexpr bool is_zero_constructible_v = is_zero_constructible<T>::value;
 
-    template <typename T>
-    concept zero_constructible = is_zero_constructible_v<T>;
-}
+template<typename T> concept zero_constructible = is_zero_constructible_v<T>;
+} // namespace draco

engine/native/core/definitions/stdtypes.cppm

@@ -6,24 +6,24 @@ module;
 export module core.stdtypes;
 
 export namespace draco {
-using i8 = int8_t;
+using i8  = int8_t;
 using i16 = int16_t;
 using i32 = int32_t;
 using i64 = int64_t;
 
 using uint = unsigned int;
-using u8 = uint8_t;
-using u16 = uint16_t;
-using u32 = uint32_t;
-using u64 = uint64_t;
+using u8   = uint8_t;
+using u16  = uint16_t;
+using u32  = uint32_t;
+using u64  = uint64_t;
 
 using f32 = float;
 using f64 = double;
 
 using isize = int64_t;
 using usize = std::size_t;
 
-using rawptr = void *;
+using rawptr  = void *;
 using uintptr = uintptr_t;
 using ptrdiff = ptrdiff_t;
 

engine/native/core/definitions/version.cppm

@@ -8,22 +8,23 @@ import core.stdtypes;
 export namespace draco {
 
 struct Version {
-  u16 major;
-  u16 minor;
-  u16 patch;
+	u16 major;
+	u16 minor;
+	u16 patch;
 };
 
 constexpr Version VERSION{.major = 2026, .minor = 0, .patch = 0};
 } // namespace draco
 
 export namespace std {
-template <> struct formatter<draco::Version> {
-  constexpr auto parse(std::format_parse_context &ctx) {
-    return ctx.begin(); // Accept any format spec (or parse custom ones)
-  }
-
-  auto format(const draco::Version &v, std::format_context &ctx) const {
-    return std::format_to(ctx.out(), "{}.{}.{}", v.major, v.minor, v.patch);
-  }
+template<> struct formatter<draco::Version> {
+	constexpr auto parse(std::format_parse_context &ctx) {
+		return ctx.begin(); // Accept any format spec (or parse custom ones)
+	}
+
+	auto format(draco::Version const &v, std::format_context &ctx) const {
+		return std::format_to(ctx.out(), "{}.{}.{}", v.major, v.minor, v.patch);
+	}
 };
+
 } // namespace std

engine/native/core/io/filesystem.cpp

@@ -9,37 +9,33 @@ module core.io.filesystem;
 
 import core.stdtypes;
 
-namespace draco::core::io::filesystem
-{
-    std::vector<u8> load_binary(const std::string& path)
-    {
-        // Open at the end (ate) to get size and in binary mode
-        std::ifstream file(path, std::ios::binary | std::ios::ate);
-
-        if (!file.is_open()) {
-            std::println("Error: Could not open file at: {}", path);
-            // Return an empty vector
-            return {}; 
-        }
-
-        std::streamsize size = file.tellg();
-        if (size < 0) {
-            std::println("Error: File is empty or unreadable: {}", path);
-            return {};
-        }
-
-        if (size == 0) {
-            return {};
-        }
-
-        file.seekg(0, std::ios::beg);
-
-        std::vector<u8> buffer(static_cast<std::size_t>(size));
-        if (file.read(reinterpret_cast<char*>(buffer.data()), size)) {
-            return buffer;
-        }
-
-        std::println("Error: Failed to read file contents: {}", path);
-        return {};
-    }
-}
+namespace draco::core::io::filesystem {
+std::vector<u8> load_binary(std::string const &path) {
+	// Open at the end (ate) to get size and in binary mode
+	std::ifstream file(path, std::ios::binary | std::ios::ate);
+
+	if (!file.is_open()) {
+		std::println("Error: Could not open file at: {}", path);
+		// Return an empty vector
+		return {};
+	}
+
+	std::streamsize size = file.tellg();
+	if (size < 0) {
+		std::println("Error: File is empty or unreadable: {}", path);
+		return {};
+	}
+
+	if (size == 0) { return {}; }
+
+	file.seekg(0, std::ios::beg);
+
+	std::vector<u8> buffer(static_cast<std::size_t>(size));
+	if (file.read(reinterpret_cast<char *>(buffer.data()), size)) {
+		return buffer;
+	}
+
+	std::println("Error: Failed to read file contents: {}", path);
+	return {};
+}
+} // namespace draco::core::io::filesystem

engine/native/core/io/filesystem.cppm

@@ -8,8 +8,7 @@ export module core.io.filesystem;
 
 import core.stdtypes;
 
-export namespace draco::core::io::filesystem
-{
-    // Returns a buffer of the file data
-    std::vector<u8> load_binary(const std::string& path);
-}
+export namespace draco::core::io::filesystem {
+// Returns a buffer of the file data
+std::vector<u8> load_binary(std::string const &path);
+} // namespace draco::core::io::filesystem