refactor: support multiple variants for games in zonecode

src/ZoneCodeGeneratorLib/Generating/BaseRenderingContext.cpp

@@ -1,9 +1,15 @@
 #include "BaseRenderingContext.h"
 
-BaseRenderingContext::BaseRenderingContext(std::string game, const WordSize gameWordSize, std::vector<const FastFileBlock*> fastFileBlocks)
+BaseRenderingContext::BaseRenderingContext(std::string game,
+                                           const WordSize gameWordSize,
+                                           const std::endian endianness,
+                                           std::vector<const FastFileBlock*> fastFileBlocks)
     : m_game(std::move(game)),
       m_word_size_mismatch(gameWordSize != OWN_WORD_SIZE),
+      m_word_size(gameWordSize),
       m_pointer_size(GetPointerSizeForWordSize(gameWordSize)),
+      m_endianness_mismatch(std::endian::native != endianness),
+      m_endianness(endianness),
       m_blocks(std::move(fastFileBlocks)),
       m_default_normal_block(nullptr),
       m_default_temp_block(nullptr)

src/ZoneCodeGeneratorLib/Generating/BaseRenderingContext.h

@@ -10,12 +10,15 @@ class BaseRenderingContext
 public:
     std::string m_game;
     bool m_word_size_mismatch;
+    WordSize m_word_size;
     unsigned m_pointer_size;
+    bool m_endianness_mismatch;
+    std::endian m_endianness;
     std::vector<const FastFileBlock*> m_blocks;
 
     const FastFileBlock* m_default_normal_block;
     const FastFileBlock* m_default_temp_block;
 
 protected:
-    BaseRenderingContext(std::string game, WordSize gameWordSize, std::vector<const FastFileBlock*> fastFileBlocks);
+    BaseRenderingContext(std::string game, WordSize gameWordSize, std::endian endianness, std::vector<const FastFileBlock*> fastFileBlocks);
 };

src/ZoneCodeGeneratorLib/Generating/CodeGenerator.cpp

@@ -141,38 +141,41 @@ bool CodeGenerator::GenerateCode(const IDataRepository* repository)
             return false;
         }
 
-        for (auto* asset : assets)
+        for (auto* variant : repository->GetGameVariants())
         {
-            auto context = OncePerAssetRenderingContext::BuildContext(repository, asset);
-            const auto result = GenerateCodeOncePerAsset(*context, foundTemplate->second.get());
-            switch (result)
+            for (auto* asset : assets)
             {
-            case utils::TextFileCheckDirtyResult::OUTPUT_WRITTEN:
-                con::info("Successfully generated code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
-                break;
-            case utils::TextFileCheckDirtyResult::OUTPUT_WAS_UP_TO_DATE:
-                con::info("Code was up to date for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
-                break;
-            case utils::TextFileCheckDirtyResult::FAILURE:
-                con::error("Failed to generate code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
-                return false;
+                auto context = OncePerAssetRenderingContext::BuildContext(repository, asset, variant);
+                const auto result = GenerateCodeOncePerAsset(*context, foundTemplate->second.get());
+                switch (result)
+                {
+                case utils::TextFileCheckDirtyResult::OUTPUT_WRITTEN:
+                    con::info("Successfully generated code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
+                    break;
+                case utils::TextFileCheckDirtyResult::OUTPUT_WAS_UP_TO_DATE:
+                    con::info("Code was up to date for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
+                    break;
+                case utils::TextFileCheckDirtyResult::FAILURE:
+                    con::error("Failed to generate code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
+                    return false;
+                }
             }
-        }
 
-        {
-            auto context = OncePerTemplateRenderingContext::BuildContext(repository);
-            const auto result = GenerateCodeOncePerTemplate(*context, foundTemplate->second.get());
-            switch (result)
             {
-            case utils::TextFileCheckDirtyResult::OUTPUT_WRITTEN:
-                con::info("Successfully generated code with preset '{}'", foundTemplate->first);
-                break;
-            case utils::TextFileCheckDirtyResult::OUTPUT_WAS_UP_TO_DATE:
-                con::info("Code was up to date for preset '{}'", foundTemplate->first);
-                break;
-            case utils::TextFileCheckDirtyResult::FAILURE:
-                con::error("Failed to generate code with preset '{}'", foundTemplate->first);
-                return false;
+                auto context = OncePerTemplateRenderingContext::BuildContext(repository, variant);
+                const auto result = GenerateCodeOncePerTemplate(*context, foundTemplate->second.get());
+                switch (result)
+                {
+                case utils::TextFileCheckDirtyResult::OUTPUT_WRITTEN:
+                    con::info("Successfully generated code with preset '{}'", foundTemplate->first);
+                    break;
+                case utils::TextFileCheckDirtyResult::OUTPUT_WAS_UP_TO_DATE:
+                    con::info("Code was up to date for preset '{}'", foundTemplate->first);
+                    break;
+                case utils::TextFileCheckDirtyResult::FAILURE:
+                    con::error("Failed to generate code with preset '{}'", foundTemplate->first);
+                    return false;
+                }
             }
         }
     }

src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.cpp

@@ -18,8 +18,11 @@ RenderingUsedType::RenderingUsedType(const DataDefinition* type, StructureInform
 {
 }
 
-OncePerAssetRenderingContext::OncePerAssetRenderingContext(std::string game, const WordSize gameWordSize, std::vector<const FastFileBlock*> fastFileBlocks)
-    : BaseRenderingContext(std::move(game), gameWordSize, std::move(fastFileBlocks)),
+OncePerAssetRenderingContext::OncePerAssetRenderingContext(std::string game,
+                                                           const WordSize gameWordSize,
+                                                           const std::endian endianness,
+                                                           std::vector<const FastFileBlock*> fastFileBlocks)
+    : BaseRenderingContext(std::move(game), gameWordSize, endianness, std::move(fastFileBlocks)),
       m_asset(nullptr),
       m_has_actions(false)
 {
@@ -185,10 +188,11 @@ bool OncePerAssetRenderingContext::UsedTypeHasActions(const RenderingUsedType* u
     return false;
 }
 
-std::unique_ptr<OncePerAssetRenderingContext> OncePerAssetRenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset)
+std::unique_ptr<OncePerAssetRenderingContext>
+    OncePerAssetRenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset, const GameVariant* variant)
 {
     auto context = std::make_unique<OncePerAssetRenderingContext>(
-        OncePerAssetRenderingContext(repository->GetGameName(), repository->GetWordSize(), repository->GetAllFastFileBlocks()));
+        OncePerAssetRenderingContext(repository->GetGameName(), variant->m_word_size, variant->m_endianness, repository->GetAllFastFileBlocks()));
 
     context->MakeAsset(repository, asset);
     context->CreateUsedTypeCollections();

src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.h

@@ -28,7 +28,8 @@ public:
 class OncePerAssetRenderingContext : public BaseRenderingContext
 {
 public:
-    static std::unique_ptr<OncePerAssetRenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
+    static std::unique_ptr<OncePerAssetRenderingContext>
+        BuildContext(const IDataRepository* repository, StructureInformation* asset, const GameVariant* variant);
 
     StructureInformation* m_asset;
 
@@ -38,7 +39,7 @@ public:
     bool m_has_actions;
 
 private:
-    OncePerAssetRenderingContext(std::string game, WordSize gameWordSize, std::vector<const FastFileBlock*> fastFileBlocks);
+    OncePerAssetRenderingContext(std::string game, WordSize gameWordSize, std::endian endianness, std::vector<const FastFileBlock*> fastFileBlocks);
 
     RenderingUsedType* AddUsedType(std::unique_ptr<RenderingUsedType> usedType);
     RenderingUsedType* GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);

src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.cpp

@@ -6,9 +6,10 @@
 
 OncePerTemplateRenderingContext::OncePerTemplateRenderingContext(std::string game,
                                                                  const WordSize gameWordSize,
+                                                                 const std::endian endianness,
                                                                  std::vector<const FastFileBlock*> fastFileBlocks,
                                                                  std::vector<StructureInformation*> assets)
-    : BaseRenderingContext(std::move(game), gameWordSize, std::move(fastFileBlocks)),
+    : BaseRenderingContext(std::move(game), gameWordSize, endianness, std::move(fastFileBlocks)),
       m_assets(std::move(assets))
 {
     for (const auto* block : m_blocks)
@@ -23,7 +24,7 @@ OncePerTemplateRenderingContext::OncePerTemplateRenderingContext(std::string gam
     }
 }
 
-std::unique_ptr<OncePerTemplateRenderingContext> OncePerTemplateRenderingContext::BuildContext(const IDataRepository* repository)
+std::unique_ptr<OncePerTemplateRenderingContext> OncePerTemplateRenderingContext::BuildContext(const IDataRepository* repository, const GameVariant* variant)
 {
     std::vector<StructureInformation*> assetInformation;
     for (auto* info : repository->GetAllStructureInformation())
@@ -34,6 +35,6 @@ std::unique_ptr<OncePerTemplateRenderingContext> OncePerTemplateRenderingContext
         assetInformation.emplace_back(info);
     }
 
-    return std::make_unique<OncePerTemplateRenderingContext>(
-        OncePerTemplateRenderingContext(repository->GetGameName(), repository->GetWordSize(), repository->GetAllFastFileBlocks(), assetInformation));
+    return std::make_unique<OncePerTemplateRenderingContext>(OncePerTemplateRenderingContext(
+        repository->GetGameName(), variant->m_word_size, variant->m_endianness, repository->GetAllFastFileBlocks(), assetInformation));
 }

src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.h

@@ -9,13 +9,14 @@
 class OncePerTemplateRenderingContext : public BaseRenderingContext
 {
 public:
-    static std::unique_ptr<OncePerTemplateRenderingContext> BuildContext(const IDataRepository* repository);
+    static std::unique_ptr<OncePerTemplateRenderingContext> BuildContext(const IDataRepository* repository, const GameVariant* variant);
 
     std::vector<StructureInformation*> m_assets;
 
 private:
     OncePerTemplateRenderingContext(std::string game,
                                     WordSize gameWordSize,
+                                    std::endian endianness,
                                     std::vector<const FastFileBlock*> fastFileBlocks,
                                     std::vector<StructureInformation*> assets);
 };

src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.cpp

@@ -70,8 +70,8 @@ namespace
 
             LINE("")
 
-            LINEF("REQUIRE({0}u == sizeof({1}));", structure->m_definition->GetSize(), structure->m_definition->GetFullName())
-            LINEF("REQUIRE({0}u == alignof({1}));", structure->m_definition->GetAlignment(), structure->m_definition->GetFullName())
+            LINEF("REQUIRE({0}u == sizeof({1}));", structure->m_definition->GetSize(m_env.m_word_size), structure->m_definition->GetFullName())
+            LINEF("REQUIRE({0}u == alignof({1}));", structure->m_definition->GetAlignment(m_env.m_word_size), structure->m_definition->GetFullName())
             m_intendation--;
             LINE("}")
         }

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp

@@ -256,12 +256,12 @@ void BaseTemplate::MakeEvaluationInternal(const IEvaluation* evaluation, std::os
         MakeOperandDynamic(dynamic_cast<const OperandDynamic*>(evaluation), str);
 }
 
-std::string BaseTemplate::MakeAllocAlignment(const StructureInformation& info)
+std::string BaseTemplate::MakeAllocAlignment(const StructureInformation& info) const
 {
     if (info.m_alloc_alignment)
         return MakeEvaluation(info.m_alloc_alignment.get());
 
-    return std::to_string(info.m_definition->GetAlignment());
+    return std::to_string(info.m_definition->GetAlignment(m_env.m_word_size));
 }
 
 std::string BaseTemplate::MakeEvaluation(const IEvaluation* evaluation)
@@ -284,12 +284,12 @@ size_t BaseTemplate::SizeForDeclModifierLevel(const MemberInformation& memberInf
 {
     const auto& declModifiers = memberInfo.m_member->m_type_declaration->m_declaration_modifiers;
     if (declModifiers.empty())
-        return memberInfo.m_member->m_type_declaration->GetSize();
+        return memberInfo.m_member->m_type_declaration->GetSize(m_env.m_word_size);
 
     if (level == 0)
-        return memberInfo.m_member->m_type_declaration->GetSize();
+        return memberInfo.m_member->m_type_declaration->GetSize(m_env.m_word_size);
 
-    size_t currentSize = memberInfo.m_member->m_type_declaration->m_type->GetSize();
+    size_t currentSize = memberInfo.m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size);
     const auto end = declModifiers.rbegin() + (declModifiers.size() - level);
     for (auto i = declModifiers.rbegin(); i != end; ++i)
     {

src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h

@@ -33,7 +33,7 @@ protected:
     static std::string MakeArrayIndices(const DeclarationModifierComputations& modifierComputations);
     static std::string MakeCustomActionCall(const CustomAction* action);
     static std::string MakeArrayCount(const ArrayDeclarationModifier* arrayModifier);
-    static std::string MakeAllocAlignment(const StructureInformation& info);
+    std::string MakeAllocAlignment(const StructureInformation& info) const;
     static std::string MakeEvaluation(const IEvaluation* evaluation);
 
     static bool ShouldGenerateFillMethod(const RenderingUsedType& type);

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp

@@ -397,14 +397,14 @@ namespace
                 LINEF("FillStruct_{0}(fillAccessor.AtOffset({1} + i * {2}));",
                       MakeSafeTypeName(memberInfo.m_member->m_type_declaration->m_type),
                       OffsetForMemberModifier(memberInfo, modifier, nestedBaseOffset),
-                      memberInfo.m_member->m_type_declaration->GetSize())
+                      memberInfo.m_member->m_type_declaration->GetSize(m_env.m_word_size))
             }
             else
             {
                 LINEF("fillAccessor.Fill({0}[i], {1} + i * {2});",
                       MakeMemberAccess(&structInfo, &memberInfo, modifier),
                       OffsetForMemberModifier(memberInfo, modifier, nestedBaseOffset),
-                      memberInfo.m_member->m_type_declaration->GetSize())
+                      memberInfo.m_member->m_type_declaration->GetSize(m_env.m_word_size))
             }
             m_intendation--;
             LINE("}")
@@ -463,7 +463,7 @@ namespace
                 LINEF("FillStruct_{0}(fillAccessor.AtOffset({1} + i * {2}));",
                       MakeSafeTypeName(memberInfo.m_member->m_type_declaration->m_type),
                       OffsetForMemberModifier(memberInfo, modifier, nestedBaseOffset),
-                      memberInfo.m_member->m_type_declaration->m_type->GetSize())
+                      memberInfo.m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 m_intendation--;
                 LINE("}")
             }
@@ -718,7 +718,7 @@ namespace
             if (memberComputations.HasDynamicArraySize())
             {
                 LINEF("const auto dynamicArrayEntries = static_cast<size_t>({0});", MakeEvaluation(modifier.GetDynamicArraySizeEvaluation()))
-                LINEF("m_stream.AppendToFill(dynamicArrayEntries * {0});", member.m_member->m_type_declaration->m_type->GetSize())
+                LINEF("m_stream.AppendToFill(dynamicArrayEntries * {0});", member.m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 LINEF("return dynamicArrayEntries * sizeof({0}{1}) + offsetof({2}, {3});",
                       MakeTypeDecl(member.m_member->m_type_declaration.get()),
                       MakeFollowingReferences(modifier.GetAllDeclarationModifiers()),
@@ -735,7 +735,7 @@ namespace
             }
             else
             {
-                LINEF("m_stream.AppendToFill({0});", member.m_member->m_type_declaration->GetSize())
+                LINEF("m_stream.AppendToFill({0});", member.m_member->m_type_declaration->GetSize(m_env.m_word_size))
                 LINEF("return sizeof({0}{1}) + offsetof({2}, {3});",
                       MakeTypeDecl(member.m_member->m_type_declaration.get()),
                       MakeFollowingReferences(modifier.GetAllDeclarationModifiers()),
@@ -888,7 +888,7 @@ namespace
 
         void PrintLoadPtrArrayMethod_Loading(const DataDefinition* def, const StructureInformation* info) const
         {
-            const auto alignment = info && def == info->m_definition ? MakeAllocAlignment(*info) : std::to_string(def->GetAlignment());
+            const auto alignment = info && def == info->m_definition ? MakeAllocAlignment(*info) : std::to_string(def->GetAlignment(m_env.m_word_size));
             if (info && !info->m_has_matching_cross_platform_structure && StructureComputations(info).GetDynamicMember())
             {
                 assert(def == info->m_definition);
@@ -1043,7 +1043,7 @@ namespace
                 LINE("{")
                 m_intendation++;
 
-                LINEF("const auto arrayFill = m_stream.LoadWithFill({0} * count);", def->GetSize())
+                LINEF("const auto arrayFill = m_stream.LoadWithFill({0} * count);", def->GetSize(m_env.m_word_size))
                 LINEF("auto* arrayStart = {0};", MakeTypeVarName(def))
                 LINEF("auto* var = {0};", MakeTypeVarName(def))
                 LINE("for (size_t index = 0; index < count; index++)")
@@ -1051,7 +1051,7 @@ namespace
                 m_intendation++;
 
                 LINEF("{0} = var;", MakeTypeVarName(info->m_definition))
-                LINEF("FillStruct_{0}(arrayFill.AtOffset(0 + {1} * index));", info->m_definition->m_name, def->GetSize())
+                LINEF("FillStruct_{0}(arrayFill.AtOffset(0 + {1} * index));", info->m_definition->m_name, def->GetSize(m_env.m_word_size))
                 LINE("var++;")
 
                 m_intendation--;
@@ -1162,14 +1162,14 @@ namespace
             else if (member->m_type && !member->m_type->m_has_matching_cross_platform_structure)
             {
                 LINEF("const auto fillArraySize = static_cast<size_t>({0});", MakeEvaluation(modifier.GetArrayPointerCountEvaluation()))
-                LINEF("const auto fill = m_stream.LoadWithFill({0} * fillArraySize);", member->m_member->m_type_declaration->m_type->GetSize())
+                LINEF("const auto fill = m_stream.LoadWithFill({0} * fillArraySize);", member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 LINE("for (auto i = 0uz; i < fillArraySize; i++)")
                 LINE("{")
                 m_intendation++;
                 LINEF("{0} = &{1}[i];", MakeTypeVarName(member->m_type->m_definition), MakeMemberAccess(info, member, modifier))
                 LINEF("FillStruct_{0}(fill.AtOffset(i * {1}));",
                       MakeSafeTypeName(member->m_type->m_definition),
-                      member->m_member->m_type_declaration->m_type->GetSize())
+                      member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 m_intendation--;
                 LINE("}")
             }
@@ -1337,7 +1337,7 @@ namespace
                 LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier))
                 LINEF("FillStruct_{0}(m_stream.LoadWithFill({1}));",
                       MakeSafeTypeName(member->m_member->m_type_declaration->m_type),
-                      member->m_member->m_type_declaration->m_type->GetSize())
+                      member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
             }
             else
             {
@@ -1460,7 +1460,7 @@ namespace
                 }
                 else
                 {
-                    LINEF("m_stream.Alloc({0});", modifier.GetAlignment())
+                    LINEF("m_stream.Alloc({0});", modifier.GetAlignment(m_env.m_word_size))
                 }
 
                 LINEF("const auto allocSize = LoadDynamicFill_{0}(m_stream.LoadWithFill(0));", MakeSafeTypeName(member->m_type->m_definition))
@@ -1491,7 +1491,7 @@ namespace
                 }
                 else
                 {
-                    LINE_MIDDLEF("{0}", modifier.GetAlignment())
+                    LINE_MIDDLEF("{0}", modifier.GetAlignment(m_env.m_word_size))
                 }
 
                 if (allocOutOfBlock && modifier.IsArrayPointer())
@@ -1617,7 +1617,7 @@ namespace
                     if (loadType == MemberLoadType::POINTER_ARRAY)
                     {
                         LINE_MIDDLEF(".OrNulled({0}uz * ({1}), sizeof({2}{3}) * ({1}), m_memory)",
-                                     member->m_member->m_type_declaration->GetSize(),
+                                     member->m_member->m_type_declaration->GetSize(m_env.m_word_size),
                                      MakeEvaluation(modifier.GetPointerArrayCountEvaluation()),
                                      MakeTypeDecl(member->m_member->m_type_declaration.get()),
                                      MakeFollowingReferences(modifier.GetFollowingDeclarationModifiers()))
@@ -1884,7 +1884,7 @@ namespace
                         LINEF("m_stream.Load<{0}>({1}); // Size: {2}",
                               info->m_definition->GetFullName(),
                               MakeTypeVarName(info->m_definition),
-                              info->m_definition->GetSize())
+                              info->m_definition->GetSize(m_env.m_word_size))
                     }
                     else
                     {
@@ -1898,7 +1898,8 @@ namespace
                 {
                     if (dynamicMember == nullptr)
                     {
-                        LINEF("FillStruct_{0}(m_stream.LoadWithFill({1}));", MakeSafeTypeName(info->m_definition), info->m_definition->GetSize())
+                        LINEF(
+                            "FillStruct_{0}(m_stream.LoadWithFill({1}));", MakeSafeTypeName(info->m_definition), info->m_definition->GetSize(m_env.m_word_size))
                     }
                     else if (info->m_non_embedded_reference_exists)
                     {

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp

@@ -489,20 +489,21 @@ namespace
                 LINEF("const auto fillArraySize = static_cast<size_t>({0});", MakeEvaluation(modifier.GetArrayPointerCountEvaluation()))
                 if (!computations.IsInRuntimeBlock())
                 {
-                    LINEF("const auto fill = m_stream->WriteWithFill({0} * fillArraySize);", member->m_member->m_type_declaration->m_type->GetSize())
+                    LINEF("const auto fill = m_stream->WriteWithFill({0} * fillArraySize);",
+                          member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                     LINE("for (auto i = 0uz; i < fillArraySize; i++)")
                     LINE("{")
                     m_intendation++;
                     LINEF("{0} = &{1}[i];", MakeTypeVarName(member->m_type->m_definition), MakeMemberAccess(info, member, modifier))
                     LINEF("FillStruct_{0}(fill.AtOffset(i * {1}));",
                           MakeSafeTypeName(member->m_type->m_definition),
-                          member->m_member->m_type_declaration->m_type->GetSize())
+                          member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                     m_intendation--;
                     LINE("}")
                 }
                 else
                 {
-                    LINEF("m_stream->IncBlockPos({0} * fillArraySize);", member->m_member->m_type_declaration->m_type->GetSize())
+                    LINEF("m_stream->IncBlockPos({0} * fillArraySize);", member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 }
             }
             else
@@ -626,7 +627,7 @@ namespace
                 LINEF("{0} = {1};", MakeTypeVarName(member->m_member->m_type_declaration->m_type), MakeMemberAccess(info, member, modifier))
                 LINEF("FillStruct_{0}(m_stream->WriteWithFill({1}));",
                       MakeSafeTypeName(member->m_member->m_type_declaration->m_type),
-                      member->m_member->m_type_declaration->m_type->GetSize())
+                      member->m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
             }
             else
             {
@@ -738,7 +739,7 @@ namespace
             {
                 if (member->m_type && !member->m_type->m_has_matching_cross_platform_structure)
                 {
-                    LINE_MIDDLEF(", {0}", member->m_type->m_definition->GetSize())
+                    LINE_MIDDLEF(", {0}", member->m_type->m_definition->GetSize(m_env.m_word_size))
                 }
 
                 LINE_MIDDLEF(", {0}", MakeEvaluation(modifier.GetArrayPointerCountEvaluation()))
@@ -813,7 +814,7 @@ namespace
             }
             else
             {
-                LINEF("m_stream->Align({0});", modifier.GetAlignment())
+                LINEF("m_stream->Align({0});", modifier.GetAlignment(m_env.m_word_size))
             }
 
             WriteMember_InsertReuse(info, member, modifier, writeType);
@@ -1115,7 +1116,7 @@ namespace
                               MakeTypeWrittenVarName(info->m_definition),
                               info->m_definition->GetFullName(),
                               MakeTypeVarName(info->m_definition),
-                              info->m_definition->GetSize())
+                              info->m_definition->GetSize(m_env.m_word_size))
                     }
                     else
                     {
@@ -1132,7 +1133,7 @@ namespace
                     LINE("{")
                     m_intendation++;
                     LINEF("const auto fillAccessor = m_stream->WriteWithFill({0});",
-                          dynamicMember == nullptr ? info->m_definition->GetSize() : dynamicMember->m_member->m_offset)
+                          dynamicMember == nullptr ? info->m_definition->GetSize(m_env.m_word_size) : dynamicMember->m_member->m_offset)
                     LINEF("{0} = fillAccessor.Offset();", MakeTypeWrittenVarName(info->m_definition))
                     LINEF("FillStruct_{0}(fillAccessor);", MakeSafeTypeName(info->m_definition))
                     m_intendation--;
@@ -1265,7 +1266,7 @@ namespace
                 LINEF("FillStruct_{0}(fillAccessor.AtOffset({1} + i * {2}));",
                       MakeSafeTypeName(memberInfo.m_member->m_type_declaration->m_type),
                       OffsetForMemberModifier(memberInfo, modifier, nestedBaseOffset),
-                      memberInfo.m_member->m_type_declaration->m_type->GetSize())
+                      memberInfo.m_member->m_type_declaration->m_type->GetSize(m_env.m_word_size))
                 m_intendation--;
                 LINE("}")
             }
@@ -1478,7 +1479,7 @@ namespace
 
         void PrintWritePtrArrayMethod_Loading(const DataDefinition* def, const StructureInformation* info, const bool reusable) const
         {
-            const auto alignment = info && def == info->m_definition ? MakeAllocAlignment(*info) : std::to_string(def->GetAlignment());
+            const auto alignment = info && def == info->m_definition ? MakeAllocAlignment(*info) : std::to_string(def->GetAlignment(m_env.m_word_size));
             LINEF("m_stream->Align({0});", alignment)
 
             if (reusable)
@@ -1590,7 +1591,7 @@ namespace
                 LINE("{")
                 m_intendation++;
 
-                LINEF("const auto arrayFill = m_stream->WriteWithFill({0} * count);", def->GetSize())
+                LINEF("const auto arrayFill = m_stream->WriteWithFill({0} * count);", def->GetSize(m_env.m_word_size))
                 LINEF("{0} = arrayFill.Offset();", MakeTypeWrittenVarName(def))
                 LINEF("auto* arrayStart = {0};", MakeTypeVarName(def))
                 LINEF("auto* var = {0};", MakeTypeVarName(def))
@@ -1599,7 +1600,7 @@ namespace
                 m_intendation++;
 
                 LINEF("{0} = var;", MakeTypeVarName(info->m_definition))
-                LINEF("FillStruct_{0}(arrayFill.AtOffset(0 + {1} * index));", info->m_definition->m_name, def->GetSize())
+                LINEF("FillStruct_{0}(arrayFill.AtOffset(0 + {1} * index));", info->m_definition->m_name, def->GetSize(m_env.m_word_size))
                 LINE("var++;")
 
                 m_intendation--;
@@ -1625,7 +1626,7 @@ namespace
             LINEF("{0} = varWritten;", MakeTypeWrittenVarName(info->m_definition))
             LINEF("Write_{0}(false);", info->m_definition->m_name)
             LINE("var++;")
-            LINEF("varWritten.Inc({0});", def->GetSize())
+            LINEF("varWritten.Inc({0});", def->GetSize(m_env.m_word_size))
 
             m_intendation--;
             LINE("}")