PredatorCZ / HavokLib / 90

Committed 07 Nov 2025 09:36AM UTC coverage: 62.461% (-1.4%) from 63.837%

Build # 90

Build Type

push

github

Committed by

PredatorCZ

Commit Message

add support for scene data

Run Details

556 of 1153 new or added lines in 22 files covered. (48.22%)

205 existing lines in 35 files now uncovered.

2777 of 4446 relevant lines covered (62.46%)

124997.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

48.63

/source/packfile/hkx_mesh.cpp

/*  Havok Format Library
    Copyright(C) 2016-2025 Lukas Cone

    This program is free software : you can redistribute it and / or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.If not, see <https://www.gnu.org/licenses/>.
*/

#include "internal/hkx_mesh.hpp"
#include "base.hpp"
#include "hklib/hkx_material.hpp"

#include "hkx_mesh.inl"

template <>
void FByteswapper(clgen::hkxVertexBuffer::Interface &interface, bool) {
  clgen::EndianSwap(interface);

  if (interface.LayoutVersion() < HK600) {
    const hkxVertexFormat &format = *interface.Format();
    uint8 *data = interface.VertexData();
    const uint32 numVertices = interface.NumVertexData();
    const uint32 stride = format.stride;

    if (format.positionOffset < 0xff) {
      for (uint32 i = 0; i < numVertices; i++) {
        FByteswapper(*reinterpret_cast<Vector4 *>(data + stride * i));
      }

      data += 16;
    }

    if (format.normalOffset < 0xff) {
      for (uint32 i = 0; i < numVertices; i++) {
        FByteswapper(*reinterpret_cast<Vector4 *>(data + stride * i));
      }

      data += 16;
    }

    if (format.tangentOffset < 0xff) {
      for (uint32 i = 0; i < numVertices; i++) {
        FByteswapper(*reinterpret_cast<Vector4 *>(data + stride * i));
      }

      data += 16;
    }

    if (format.binormalOffset < 0xff) {
      for (uint32 i = 0; i < numVertices; i++) {
        FByteswapper(*reinterpret_cast<Vector4 *>(data + stride * i));
      }

      data += 16;
    }

    if (format.numBonesPerVertex > 0) {
      if (format.boneIndexOffset < 0xff) {
        data += 4;
      }

      if (format.boneWeightOffset < 0xff) {
        data += 4;
      }
    }

    if (format.colorOffset < 0xff) {
      data += 4;
    }

    for (uint8 t = 0; t < format.numTextureChannels; t++) {
      if (format.tFloatCoordOffset < 0xff) {
        for (uint32 i = 0; i < numVertices; i++) {
          FByteswapper(*reinterpret_cast<Vector2 *>(data + stride * i));
        }

        data += 8;
      } else if (format.tQuantizedCoordOffset < 0xff) {
        for (uint32 i = 0; i < numVertices; i++) {
          FByteswapper(*reinterpret_cast<USVector2 *>(data + stride * i));
        }

        data += 4;
      }
    }
  }

  if (interface.LayoutVersion() >= HK700) {
    auto vdata = interface.Data_();
    clgen::EndianSwap(vdata);

    float *floatData = vdata.FloatData();
    uint32 numItems = vdata.NumFloatData();

    for (uint32 i = 0; i < numItems; i++) {
      FByteswapper(floatData[i]);
    }

    uint16 *uint16Data = vdata.Uint16Data();
    numItems = vdata.NumUint16Data();

    for (uint32 i = 0; i < numItems; i++) {
      FByteswapper(uint16Data[i]);
    }

    uint32 *uint32Data = vdata.Uint32Data();
    numItems = vdata.NumUint32Data();

    for (uint32 i = 0; i < numItems; i++) {
      FByteswapper(uint32Data[i]);
    }

    numItems = vdata.NumVectorData();

    if (interface.LayoutVersion() >= HK2013_1) {
      float *vecData = vdata.VectorDataHK2013_1();

      for (uint32 i = 0; i < numItems; i++) {
        FByteswapper(vecData[i]);
      }
    } else {
      Vector4 *vecData = vdata.VectorData();

      for (uint32 i = 0; i < numItems; i++) {
        FByteswapper(vecData[i]);
      }
    }
  }
}

struct hkxIndexBufferMidInterface : hkxIndexBufferInternalInterface {
  clgen::hkxIndexBuffer::Interface interface;

  hkxIndexBufferMidInterface(clgen::LayoutLookup rules, char *data)
      : interface{data, rules} {}

  hkxIndexBufferMidInterface(const clgen::hkxIndexBuffer::Interface &interface)
      : interface(interface) {}

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  void SwapEndian() override {
    clgen::EndianSwap(interface);

    uint32 *indices32 = interface.Indices32();
    const uint32 numIndices32 = interface.NumIndices32();
    for (uint32 i = 0; i < numIndices32; i++) {
      FByteswapper(indices32[i]);
    }

    uint16 *indices16 = interface.Indices16();
    const uint32 numIndices16 = interface.NumIndices16();
    for (uint32 i = 0; i < numIndices16; i++) {
      FByteswapper(indices16[i]);
    }
  }

  IndexType GetIndexType() const override { return interface.IndexType(); }

  size_t NumIndices() const override {
    return interface.NumIndices16() + interface.NumIndices32();
  }

  bool Is32Bit() const override { return interface.NumIndices32() > 0; }

  const char *Indices() const override {
    const uint16 *indices16 = interface.Indices16();
    const uint32 *indices32 = interface.Indices32();

    if (indices16) {
      return reinterpret_cast<const char *>(indices16);
    }

    return reinterpret_cast<const char *>(indices32);
  }

  uint32 VerrtexBaseOffset() const override {
    return interface.VertexBaseOffset();
  }

  uint32 Length() const override { return interface.Length(); }
};

struct hkxVertexDescriptionMidInterface
    : hkxVertexDescriptionInternalInterface {
  clgen::hkxVertexDescription::Interface interface;

  hkxVertexDescriptionMidInterface(clgen::LayoutLookup rules, char *data)
      : interface{data, rules} {}

  hkxVertexDescriptionMidInterface(
      const clgen::hkxVertexDescription::Interface &interface)
      : interface(interface) {}

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  size_t GetNumDecls() const override { return interface.NumDecls(); }

  void SwapEndian() override {
    clgen::EndianSwap(interface);
    auto decls = interface.Decls();
    const uint32 numDecls = interface.NumDecls();

    for (uint32 i = 0; i < numDecls; i++, decls.Next()) {
      clgen::EndianSwap(decls);
    }
  }

  hkxVertexDescriptionElementDecl GetDecls(size_t at) const override {
    auto decl = interface.Decls().Next(at);
    hkxVertexDescriptionElementDecl retval{
        .byteOffset = decl.ByteOffset(),
        .byteStride = interface.LayoutVersion() >= HK700 ? decl.ByteStride()
                                                         : interface.Stride(),
        .type = decl.Type(),
        .usage = decl.Usage(),
        .channelId = decl.ChannelID(),
    };

    if (interface.LayoutVersion() >= HK2012_2 &&
        interface.LayoutVersion() < HK2014 &&
        decl.Hint() == hkxVertexDescriptionDataHint::LIGHTMAP) {
      retval.channelId = "lightmap";
    }

    return retval;
  }
};

struct hkxVertexDescriptionFromFormat : hkxVertexDescriptionInternalInterface {
  std::vector<hkxVertexDescriptionElementDecl> decls;

  hkxVertexDescriptionFromFormat(const hkxVertexFormat &format) {
    uint32 curOffset = 0;

    if (format.positionOffset < 0xff) {
      decls.emplace_back(hkxVertexDescriptionElementDecl{
          .byteOffset = curOffset,
          .byteStride = format.stride,
          .type = DataType::FLOAT4,
          .usage = DataUsage::POSITION,
      });
      curOffset += 16;
    }

    if (format.normalOffset < 0xff) {
      decls.emplace_back(hkxVertexDescriptionElementDecl{
          .byteOffset = curOffset,
          .byteStride = format.stride,
          .type = DataType::FLOAT4,
          .usage = DataUsage::NORMAL,
      });
      curOffset += 16;
    }

    if (format.tangentOffset < 0xff) {
      decls.emplace_back(hkxVertexDescriptionElementDecl{
          .byteOffset = curOffset,
          .byteStride = format.stride,
          .type = DataType::FLOAT4,
          .usage = DataUsage::TANGENT,
      });
      curOffset += 16;
    }

    if (format.binormalOffset < 0xff) {
      decls.emplace_back(hkxVertexDescriptionElementDecl{
          .byteOffset = curOffset,
          .byteStride = format.stride,
          .type = DataType::FLOAT4,
          .usage = DataUsage::BINORMAL,
      });
      curOffset += 16;
    }

    if (format.numBonesPerVertex > 0) {
      if (format.boneIndexOffset < 0xff) {
        decls.emplace_back(hkxVertexDescriptionElementDecl{
            .byteOffset = curOffset,
            .byteStride = format.stride,
            .type = DataType::UINT8,
            .usage = DataUsage::BLENDINDICES,
        });
        curOffset += 4;
      }

      if (format.boneWeightOffset < 0xff) {
        decls.emplace_back(hkxVertexDescriptionElementDecl{
            .byteOffset = curOffset,
            .byteStride = format.stride,
            .type = DataType::UINT8,
            .usage = DataUsage::BLENDWEIGHTS,
        });
        curOffset += 4;
      }
    }

    if (format.colorOffset < 0xff) {
      decls.emplace_back(hkxVertexDescriptionElementDecl{
          .byteOffset = curOffset,
          .byteStride = format.stride,
          .type = DataType::UINT32,
          .usage = DataUsage::COLOR,
      });
      curOffset += 4;
    }

    for (uint8 t = 0; t < format.numTextureChannels; t++) {
      if (format.tFloatCoordOffset < 0xff) {
        decls.emplace_back(hkxVertexDescriptionElementDecl{
            .byteOffset = curOffset,
            .byteStride = format.stride,
            .type = DataType::FLOAT2,
            .usage = DataUsage::TEXCOORD,
        });
        curOffset += 8;
      } else if (format.tQuantizedCoordOffset < 0xff) {
        decls.emplace_back(hkxVertexDescriptionElementDecl{
            .byteOffset = curOffset,
            .byteStride = format.stride,
            .type = DataType::INT16,
            .usage = DataUsage::TEXCOORD,
        });
        curOffset += 4;
      }
    }
  };

  void SetDataPointer(void *) override {}

  const void *GetPointer() const override { return this; }

  void SwapEndian() override {}

  size_t GetNumDecls() const override { return decls.size(); }

  hkxVertexDescriptionElementDecl GetDecls(size_t at) const override {
    return decls.at(at);
  }
};

struct hkxVertexBufferMidInterface : hkxVertexBufferInternalInterface {
  clgen::hkxVertexBuffer::Interface interface;

  hkxVertexBufferMidInterface(clgen::LayoutLookup rules, char *data)
      : interface{data, rules} {}

  hkxVertexBufferMidInterface(
      const clgen::hkxVertexBuffer::Interface &interface)
      : interface(interface) {}

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  void SwapEndian() override { FByteswapper(interface); }

  uint32 NumVertices() const override {
    return interface.LayoutVersion() >= HK700 ? interface.Data_().NumVerts()
                                              : interface.NumVertexData();
  }

  const char *VertexData(DataType type) const override {
    if (interface.LayoutVersion() >= HK700) {
      auto data = interface.Data_();
      switch (type) {
      case DataType::FLOAT:
      case DataType::FLOAT2:
        return reinterpret_cast<const char *>(data.FloatData());
      case DataType::FLOAT3:
      case DataType::FLOAT4:
        return reinterpret_cast<const char *>(data.VectorData());
      case DataType::UINT8:
        return reinterpret_cast<const char *>(data.Uint8Data());
      case DataType::INT16:
        return reinterpret_cast<const char *>(data.Uint16Data());
      case DataType::UINT32:
        return reinterpret_cast<const char *>(data.Uint32Data());
      case DataType::NONE:
        return nullptr;
      }
    }
    const uint8 *data = interface.VertexData();
    return reinterpret_cast<const char *>(data);
  }

  uni::Element<const hkxVertexDescription> VertexDesc() const override {
    if (interface.LayoutVersion() < HK600) {
      return {new hkxVertexDescriptionFromFormat(*interface.Format()), true};
    }
    return {new hkxVertexDescriptionMidInterface(interface.VertexDesc()), true};
  }
};

struct hkxVertexAnimationMidInterface : hkxVertexAnimationInternalInterface {
  clgen::hkxVertexAnimation::Interface interface;

  hkxVertexAnimationMidInterface(
      const clgen::hkxVertexAnimation::Interface &interface)
      : interface{interface} {}

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  void SwapEndian() override {
    clgen::EndianSwap(interface);
    auto vertData = interface.VertData();
    FByteswapper(vertData);
    int32 *vtxIndices = interface.VertexIndexMap();
    uint32 numVtxIdx = interface.NumVertexIndexMap();

    for (uint32 i = 0; i < numVtxIdx; i++) {
      FByteswapper(vtxIndices[i]);
    }

    hkxVertexAnimationUsageMap *components = interface.ComponentMap();
    const uint32 numComponents = interface.NumComponentMap();

    for (uint32 i = 0; i < numComponents; i++) {
      FByteswapper(components[i].use);
    }
  }

  float Time() const override { return interface.Time(); }

  uni::Element<hkxVertexBuffer> VertData() const override {
    return {new hkxVertexBufferMidInterface(interface.VertData()), true};
  }

  std::span<const int32> VertexIndexMap() const override {
    return {interface.VertexIndexMap(), interface.NumVertexIndexMap()};
  }

  std::span<const hkxVertexAnimationUsageMap> ComponentMaps() const override {
    return {interface.ComponentMap(), interface.NumComponentMap()};
  }
};

struct hkxMeshSectionMidInterface : hkxMeshSectionInternalInterface {
  clgen::hkxMeshSection::Interface interface;

  hkxMeshSectionMidInterface(clgen::LayoutLookup rules, char *data)
      : interface{data, rules} {}

  hkxMeshSectionMidInterface(const clgen::hkxMeshSection::Interface &interface,
                             IhkPackFile *header)
      : interface(interface) {
    this->header = header;
  }

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  void SwapEndian() override {
    clgen::EndianSwap(interface);
    auto boneMatricesMap = interface.BoneMatrixMap();
    const uint32 numBoneMatricesMaps = interface.NumBoneMatrixMap();

    for (uint32 i = 0; i < numBoneMatricesMaps; i++, boneMatricesMap.Next()) {
      clgen::EndianSwap(boneMatricesMap);
      int16 *mapping = boneMatricesMap.Mapping();
      uint32 numMappings = boneMatricesMap.NumMapping();

      for (uint32 j = 0; j < numMappings; j++) {
        FByteswapper(mapping[j]);
      }
    }

    float *linearKFs = interface.LinearKeyFrameHints();
    uint32 numLinearKFs = interface.NumLinearKeyFrameHints();

    for (uint32 i = 0; i < numLinearKFs; i++) {
      FByteswapper(linearKFs[i]);
    }
  }

  uni::Element<const hkxVertexBuffer> VertexBuffer() const override {
    return {new hkxVertexBufferMidInterface(*interface.VertexBuffer()), true};
  }

  size_t GetNumIndexBuffers() const override {
    return interface.NumIndexBuffers();
  }

  uni::Element<const hkxIndexBuffer> GetIndexBuffer(size_t at) const override {
    return {new hkxIndexBufferMidInterface(**interface.IndexBuffers().Next(at)),
            true};
  }

  const hkxMaterial *Material() const override {
    return *header->GetClass(interface.Material().data);
  }

  size_t GetNumUserChannels() const override {
    return interface.NumUserChannels();
  }

  const IhkVirtualClass *GetUserChannel(size_t at) const override {
    return header->GetClass(interface.UserChannels().Next(at).Object());
  }

  size_t GetNumVertexAnimations() const override {
    return interface.NumVertexAnimations();
  }

  uni::Element<hkxVertexAnimation>
  GetVertexAnimation(size_t at) const override {
    return {new hkxVertexAnimationMidInterface(
                **interface.VertexAnimations().Next(at)),
            true};
  }

  std::span<const float> LinearKeyFrameHints() const override {
    return {interface.LinearKeyFrameHints(),
            interface.NumLinearKeyFrameHints()};
  }

  size_t NumBoneMatrixMaps() const override {
    return interface.NumBoneMatrixMap();
  }

  std::span<const int16> BoneMatrixMapping(size_t at) const override {
    return {interface.BoneMatrixMap().Next(at).Mapping(),
            interface.BoneMatrixMap().Next(at).NumMapping()};
  }
};

struct hkxMeshMidInterface : hkxMeshInternalInterface {
  clgen::hkxMesh::Interface interface;

  hkxMeshMidInterface(clgen::LayoutLookup rules, char *data)
      : interface{data, rules} {}
  hkxMeshMidInterface(const clgen::hkxMesh::Interface &interface)
      : interface{interface} {}

  void SetDataPointer(void *ptr) override {
    interface.data = static_cast<char *>(ptr);
  }

  const void *GetPointer() const override { return interface.data; }

  void SwapEndian() override { clgen::EndianSwap(interface); }

  size_t GetNumSections() const override { return interface.NumSections(); }

  uni::Element<const hkxMeshSection> GetSection(size_t at) const override {
    return {
        new hkxMeshSectionMidInterface(**interface.Sections().Next(at), header),
        true};
  }

  size_t GetNumUserChannelInfos() const override {
    return interface.NumUserChannelInfos();
  }

  hkxMeshUserChannelInfo GetUserChannelInfo(size_t at) const override {
    auto info = interface.UserChannelInfos().Next(at);

    return {
        .name = info.Name(),
        .className = info.ClassName(),
    };
  }
};

hkxMeshInternalInterface *hkxMeshInternalInterface::Create(void *interface) {
  return new hkxMeshMidInterface(
      *static_cast<clgen::hkxMesh::Interface *>(interface));
}

CREATE_HK_CLASS(hkxMesh);
CREATE_HK_CLASS(hkxVertexBuffer);
CREATE_HK_CLASS(hkxIndexBuffer);
CREATE_HK_CLASS(hkxMeshSection);
CREATE_HK_CLASS(hkxVertexDescription);

1	/* Havok Format Library
2	Copyright(C) 2016-2025 Lukas Cone
3
4	This program is free software : you can redistribute it and / or modify
5	it under the terms of the GNU General Public License as published by
6	the Free Software Foundation, either version 3 of the License, or
7	(at your option) any later version.
8
9	This program is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
12	GNU General Public License for more details.
13
14	You should have received a copy of the GNU General Public License
15	along with this program.If not, see <https://www.gnu.org/licenses/>.
16	*/
17
18	#include "internal/hkx_mesh.hpp"
19	#include "base.hpp"
20	#include "hklib/hkx_material.hpp"
21
22	#include "hkx_mesh.inl"
23
24	template <>
25	void FByteswapper(clgen::hkxVertexBuffer::Interface &interface, bool) {	32✔
26	clgen::EndianSwap(interface);	32✔
27
28	if (interface.LayoutVersion() < HK600) {	32✔
29	const hkxVertexFormat &format = *interface.Format();
30	uint8 *data = interface.VertexData();
31	const uint32 numVertices = interface.NumVertexData();
32	const uint32 stride = format.stride;	4✔
33
34	if (format.positionOffset < 0xff) {	4✔
35	for (uint32 i = 0; i < numVertices; i++) {	12,292✔
36	FByteswapper(reinterpret_cast<Vector4 >(data + stride * i));	12,288✔
37	}
38
39	data += 16;	4✔
40	}
41
42	if (format.normalOffset < 0xff) {	4✔
43	for (uint32 i = 0; i < numVertices; i++) {	12,292✔
44	FByteswapper(reinterpret_cast<Vector4 >(data + stride * i));	12,288✔
45	}
46
47	data += 16;	4✔
48	}
49
50	if (format.tangentOffset < 0xff) {	4✔
NEW 51	for (uint32 i = 0; i < numVertices; i++) {	×
NEW 52	FByteswapper(reinterpret_cast<Vector4 >(data + stride * i));	×
53	}
54
NEW 55	data += 16;	×
56	}
57
58	if (format.binormalOffset < 0xff) {	4✔
NEW 59	for (uint32 i = 0; i < numVertices; i++) {	×
NEW 60	FByteswapper(reinterpret_cast<Vector4 >(data + stride * i));	×
61	}
62
NEW 63	data += 16;	×
64	}
65
66	if (format.numBonesPerVertex > 0) {	4✔
67	if (format.boneIndexOffset < 0xff) {	4✔
68	data += 4;	4✔
69	}
70
71	if (format.boneWeightOffset < 0xff) {	4✔
72	data += 4;	4✔
73	}
74	}
75
76	if (format.colorOffset < 0xff) {	4✔
NEW 77	data += 4;	×
78	}
79
80	for (uint8 t = 0; t < format.numTextureChannels; t++) {	8✔
81	if (format.tFloatCoordOffset < 0xff) {	4✔
NEW 82	for (uint32 i = 0; i < numVertices; i++) {	×
NEW 83	FByteswapper(reinterpret_cast<Vector2 >(data + stride * i));	×
84	}
85
NEW 86	data += 8;	×
87	} else if (format.tQuantizedCoordOffset < 0xff) {	4✔
88	for (uint32 i = 0; i < numVertices; i++) {	12,292✔
89	FByteswapper(reinterpret_cast<USVector2 >(data + stride * i));	12,288✔
90	}
91
92	data += 4;	4✔
93	}
94	}
95	}
96
97	if (interface.LayoutVersion() >= HK700) {	32✔
98	auto vdata = interface.Data_();	24✔
99	clgen::EndianSwap(vdata);	24✔
100
101	float *floatData = vdata.FloatData();
102	uint32 numItems = vdata.NumFloatData();
103
104	for (uint32 i = 0; i < numItems; i++) {	24✔
NEW 105	FByteswapper(floatData[i]);	×
106	}
107
108	uint16 *uint16Data = vdata.Uint16Data();
109	numItems = vdata.NumUint16Data();
110
111	for (uint32 i = 0; i < numItems; i++) {	147,480✔
112	FByteswapper(uint16Data[i]);	147,456✔
113	}
114
115	uint32 *uint32Data = vdata.Uint32Data();
116	numItems = vdata.NumUint32Data();
117
118	for (uint32 i = 0; i < numItems; i++) {	24✔
NEW 119	FByteswapper(uint32Data[i]);	×
120	}
121
122	numItems = vdata.NumVectorData();
123
124	if (interface.LayoutVersion() >= HK2013_1) {	24✔
125	float *vecData = vdata.VectorDataHK2013_1();
126
127	for (uint32 i = 0; i < numItems; i++) {	196,616✔
128	FByteswapper(vecData[i]);	196,608✔
129	}
130	} else {
131	Vector4 *vecData = vdata.VectorData();
132
133	for (uint32 i = 0; i < numItems; i++) {	98,320✔
134	FByteswapper(vecData[i]);	98,304✔
135	}
136	}
137	}
138	}	32✔
139
140	struct hkxIndexBufferMidInterface : hkxIndexBufferInternalInterface {
141	clgen::hkxIndexBuffer::Interface interface;
142
143	hkxIndexBufferMidInterface(clgen::LayoutLookup rules, char *data)	64✔
144	: interface{data, rules} {}	64✔
145
146	hkxIndexBufferMidInterface(const clgen::hkxIndexBuffer::Interface &interface)
147	: interface(interface) {}	8✔
148
149	void SetDataPointer(void *ptr) override {	64✔
150	interface.data = static_cast<char *>(ptr);	64✔
151	}	64✔
152
153	const void *GetPointer() const override { return interface.data; }	32✔
154
155	void SwapEndian() override {	32✔
156	clgen::EndianSwap(interface);	32✔
157
158	uint32 *indices32 = interface.Indices32();
159	const uint32 numIndices32 = interface.NumIndices32();
160	for (uint32 i = 0; i < numIndices32; i++) {	32✔
NEW 161	FByteswapper(indices32[i]);	×
162	}
163
164	uint16 *indices16 = interface.Indices16();
165	const uint32 numIndices16 = interface.NumIndices16();
166	for (uint32 i = 0; i < numIndices16; i++) {	32✔
NEW 167	FByteswapper(indices16[i]);	×
168	}
169	}	32✔
170
171	IndexType GetIndexType() const override { return interface.IndexType(); }	8✔
172
173	size_t NumIndices() const override {	16✔
174	return interface.NumIndices16() + interface.NumIndices32();	16✔
175	}
176
177	bool Is32Bit() const override { return interface.NumIndices32() > 0; }	16✔
178
NEW 179	const char *Indices() const override {	×
180	const uint16 *indices16 = interface.Indices16();
181	const uint32 *indices32 = interface.Indices32();
182
NEW 183	if (indices16) {	×
NEW 184	return reinterpret_cast<const char *>(indices16);	×
185	}
186
187	return reinterpret_cast<const char *>(indices32);
188	}
189
190	uint32 VerrtexBaseOffset() const override {	8✔
191	return interface.VertexBaseOffset();	8✔
192	}
193
194	uint32 Length() const override { return interface.Length(); }	8✔
195	};
196
197	struct hkxVertexDescriptionMidInterface
198	: hkxVertexDescriptionInternalInterface {
199	clgen::hkxVertexDescription::Interface interface;
200
201	hkxVertexDescriptionMidInterface(clgen::LayoutLookup rules, char *data)	8✔
202	: interface{data, rules} {}	8✔
203
204	hkxVertexDescriptionMidInterface(
205	const clgen::hkxVertexDescription::Interface &interface)
NEW 206	: interface(interface) {}	×
207
208	void SetDataPointer(void *ptr) override {	8✔
209	interface.data = static_cast<char *>(ptr);	8✔
210	}	8✔
211
NEW 212	const void *GetPointer() const override { return interface.data; }	×
213
NEW 214	size_t GetNumDecls() const override { return interface.NumDecls(); }	×
215
216	void SwapEndian() override {	4✔
217	clgen::EndianSwap(interface);	4✔
218	auto decls = interface.Decls();	4✔
219	const uint32 numDecls = interface.NumDecls();
220
221	for (uint32 i = 0; i < numDecls; i++, decls.Next()) {	24✔
222	clgen::EndianSwap(decls);	20✔
223	}
224	}	4✔
225
NEW 226	hkxVertexDescriptionElementDecl GetDecls(size_t at) const override {	×
NEW 227	auto decl = interface.Decls().Next(at);	×
228	hkxVertexDescriptionElementDecl retval{
229	.byteOffset = decl.ByteOffset(),
NEW 230	.byteStride = interface.LayoutVersion() >= HK700 ? decl.ByteStride()	×
231	: interface.Stride(),
232	.type = decl.Type(),
233	.usage = decl.Usage(),
234	.channelId = decl.ChannelID(),
235	};
236
NEW 237	if (interface.LayoutVersion() >= HK2012_2 &&	×
NEW 238	interface.LayoutVersion() < HK2014 &&	×
239	decl.Hint() == hkxVertexDescriptionDataHint::LIGHTMAP) {
NEW 240	retval.channelId = "lightmap";	×
241	}
242
NEW 243	return retval;	×
244	}
245	};
246
247	struct hkxVertexDescriptionFromFormat : hkxVertexDescriptionInternalInterface {
248	std::vector<hkxVertexDescriptionElementDecl> decls;
249
NEW 250	hkxVertexDescriptionFromFormat(const hkxVertexFormat &format) {	×
251	uint32 curOffset = 0;
252
NEW 253	if (format.positionOffset < 0xff) {	×
NEW 254	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
255	.byteOffset = curOffset,
NEW 256	.byteStride = format.stride,	×
257	.type = DataType::FLOAT4,
258	.usage = DataUsage::POSITION,
259	});
260	curOffset += 16;
261	}
262
NEW 263	if (format.normalOffset < 0xff) {	×
NEW 264	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
265	.byteOffset = curOffset,
NEW 266	.byteStride = format.stride,	×
267	.type = DataType::FLOAT4,
268	.usage = DataUsage::NORMAL,
269	});
NEW 270	curOffset += 16;	×
271	}
272
NEW 273	if (format.tangentOffset < 0xff) {	×
NEW 274	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
275	.byteOffset = curOffset,
NEW 276	.byteStride = format.stride,	×
277	.type = DataType::FLOAT4,
278	.usage = DataUsage::TANGENT,
279	});
NEW 280	curOffset += 16;	×
281	}
282
NEW 283	if (format.binormalOffset < 0xff) {	×
NEW 284	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
285	.byteOffset = curOffset,
NEW 286	.byteStride = format.stride,	×
287	.type = DataType::FLOAT4,
288	.usage = DataUsage::BINORMAL,
289	});
NEW 290	curOffset += 16;	×
291	}
292
NEW 293	if (format.numBonesPerVertex > 0) {	×
NEW 294	if (format.boneIndexOffset < 0xff) {	×
NEW 295	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
296	.byteOffset = curOffset,
NEW 297	.byteStride = format.stride,	×
298	.type = DataType::UINT8,
299	.usage = DataUsage::BLENDINDICES,
300	});
NEW 301	curOffset += 4;	×
302	}
303
NEW 304	if (format.boneWeightOffset < 0xff) {	×
NEW 305	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
306	.byteOffset = curOffset,
NEW 307	.byteStride = format.stride,	×
308	.type = DataType::UINT8,
309	.usage = DataUsage::BLENDWEIGHTS,
310	});
NEW 311	curOffset += 4;	×
312	}
313	}
314
NEW 315	if (format.colorOffset < 0xff) {	×
NEW 316	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
317	.byteOffset = curOffset,
NEW 318	.byteStride = format.stride,	×
319	.type = DataType::UINT32,
320	.usage = DataUsage::COLOR,
321	});
NEW 322	curOffset += 4;	×
323	}
324
NEW 325	for (uint8 t = 0; t < format.numTextureChannels; t++) {	×
NEW 326	if (format.tFloatCoordOffset < 0xff) {	×
NEW 327	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
328	.byteOffset = curOffset,
NEW 329	.byteStride = format.stride,	×
330	.type = DataType::FLOAT2,
331	.usage = DataUsage::TEXCOORD,
332	});
NEW 333	curOffset += 8;	×
NEW 334	} else if (format.tQuantizedCoordOffset < 0xff) {	×
NEW 335	decls.emplace_back(hkxVertexDescriptionElementDecl{	×
336	.byteOffset = curOffset,
NEW 337	.byteStride = format.stride,	×
338	.type = DataType::INT16,
339	.usage = DataUsage::TEXCOORD,
340	});
NEW 341	curOffset += 4;	×
342	}
343	}
344	};
345
NEW 346	void SetDataPointer(void *) override {}	×
347
NEW 348	const void *GetPointer() const override { return this; }	×
349
NEW 350	void SwapEndian() override {}	×
351
NEW 352	size_t GetNumDecls() const override { return decls.size(); }	×
353
NEW 354	hkxVertexDescriptionElementDecl GetDecls(size_t at) const override {	×
NEW 355	return decls.at(at);	×
356	}
357	};
358
359	struct hkxVertexBufferMidInterface : hkxVertexBufferInternalInterface {
360	clgen::hkxVertexBuffer::Interface interface;
361
362	hkxVertexBufferMidInterface(clgen::LayoutLookup rules, char *data)	64✔
363	: interface{data, rules} {}	64✔
364
365	hkxVertexBufferMidInterface(
366	const clgen::hkxVertexBuffer::Interface &interface)
367	: interface(interface) {}	8✔
368
369	void SetDataPointer(void *ptr) override {	64✔
370	interface.data = static_cast<char *>(ptr);	64✔
371	}	64✔
372
373	const void *GetPointer() const override { return interface.data; }	32✔
374
375	void SwapEndian() override { FByteswapper(interface); }	32✔
376
377	uint32 NumVertices() const override {	8✔
378	return interface.LayoutVersion() >= HK700 ? interface.Data_().NumVerts()	8✔
379	: interface.NumVertexData();	8✔
380	}
381
NEW 382	const char *VertexData(DataType type) const override {	×
NEW 383	if (interface.LayoutVersion() >= HK700) {	×
NEW 384	auto data = interface.Data_();	×
NEW 385	switch (type) {	×
386	case DataType::FLOAT:
387	case DataType::FLOAT2:
NEW 388	return reinterpret_cast<const char *>(data.FloatData());	×
389	case DataType::FLOAT3:
390	case DataType::FLOAT4:
391	return reinterpret_cast<const char *>(data.VectorData());
392	case DataType::UINT8:
393	return reinterpret_cast<const char *>(data.Uint8Data());
394	case DataType::INT16:
395	return reinterpret_cast<const char *>(data.Uint16Data());
396	case DataType::UINT32:
397	return reinterpret_cast<const char *>(data.Uint32Data());
398	case DataType::NONE:
399	return nullptr;
400	}
401	}
402	const uint8 *data = interface.VertexData();
403	return reinterpret_cast<const char *>(data);
404	}
405
NEW 406	uni::Element<const hkxVertexDescription> VertexDesc() const override {	×
NEW 407	if (interface.LayoutVersion() < HK600) {	×
NEW 408	return {new hkxVertexDescriptionFromFormat(*interface.Format()), true};	×
409	}
NEW 410	return {new hkxVertexDescriptionMidInterface(interface.VertexDesc()), true};	×
411	}
412	};
413
414	struct hkxVertexAnimationMidInterface : hkxVertexAnimationInternalInterface {
415	clgen::hkxVertexAnimation::Interface interface;
416
417	hkxVertexAnimationMidInterface(
418	const clgen::hkxVertexAnimation::Interface &interface)
NEW 419	: interface{interface} {}	×
420
NEW 421	void SetDataPointer(void *ptr) override {	×
NEW 422	interface.data = static_cast<char *>(ptr);	×
423	}
424
NEW 425	const void *GetPointer() const override { return interface.data; }	×
426
NEW 427	void SwapEndian() override {	×
NEW 428	clgen::EndianSwap(interface);	×
NEW 429	auto vertData = interface.VertData();	×
NEW 430	FByteswapper(vertData);	×
431	int32 *vtxIndices = interface.VertexIndexMap();
432	uint32 numVtxIdx = interface.NumVertexIndexMap();
433
NEW 434	for (uint32 i = 0; i < numVtxIdx; i++) {	×
NEW 435	FByteswapper(vtxIndices[i]);	×
436	}
437
438	hkxVertexAnimationUsageMap *components = interface.ComponentMap();
439	const uint32 numComponents = interface.NumComponentMap();
440
NEW 441	for (uint32 i = 0; i < numComponents; i++) {	×
NEW 442	FByteswapper(components[i].use);	×
443	}
444	}
445
NEW 446	float Time() const override { return interface.Time(); }	×
447
NEW 448	uni::Element<hkxVertexBuffer> VertData() const override {	×
NEW 449	return {new hkxVertexBufferMidInterface(interface.VertData()), true};	×
450	}
451
NEW 452	std::span<const int32> VertexIndexMap() const override {	×
NEW 453	return {interface.VertexIndexMap(), interface.NumVertexIndexMap()};	×
454	}
455
NEW 456	std::span<const hkxVertexAnimationUsageMap> ComponentMaps() const override {	×
NEW 457	return {interface.ComponentMap(), interface.NumComponentMap()};	×
458	}
459	};
460
461	struct hkxMeshSectionMidInterface : hkxMeshSectionInternalInterface {
462	clgen::hkxMeshSection::Interface interface;
463
464	hkxMeshSectionMidInterface(clgen::LayoutLookup rules, char *data)	64✔
465	: interface{data, rules} {}	64✔
466
467	hkxMeshSectionMidInterface(const clgen::hkxMeshSection::Interface &interface,
468	IhkPackFile *header)
469	: interface(interface) {	8✔
470	this->header = header;	8✔
471	}
472
473	void SetDataPointer(void *ptr) override {	64✔
474	interface.data = static_cast<char *>(ptr);	64✔
475	}	64✔
476
477	const void *GetPointer() const override { return interface.data; }	32✔
478
479	void SwapEndian() override {	32✔
480	clgen::EndianSwap(interface);	32✔
481	auto boneMatricesMap = interface.BoneMatrixMap();	32✔
482	const uint32 numBoneMatricesMaps = interface.NumBoneMatrixMap();
483
484	for (uint32 i = 0; i < numBoneMatricesMaps; i++, boneMatricesMap.Next()) {	32✔
NEW 485	clgen::EndianSwap(boneMatricesMap);	×
486	int16 *mapping = boneMatricesMap.Mapping();
487	uint32 numMappings = boneMatricesMap.NumMapping();
488
NEW 489	for (uint32 j = 0; j < numMappings; j++) {	×
NEW 490	FByteswapper(mapping[j]);	×
491	}
492	}
493
494	float *linearKFs = interface.LinearKeyFrameHints();
495	uint32 numLinearKFs = interface.NumLinearKeyFrameHints();
496
497	for (uint32 i = 0; i < numLinearKFs; i++) {	32✔
NEW 498	FByteswapper(linearKFs[i]);	×
499	}
500	}	32✔
501
502	uni::Element<const hkxVertexBuffer> VertexBuffer() const override {	8✔
503	return {new hkxVertexBufferMidInterface(*interface.VertexBuffer()), true};	8✔
504	}
505
506	size_t GetNumIndexBuffers() const override {	16✔
507	return interface.NumIndexBuffers();	16✔
508	}
509
510	uni::Element<const hkxIndexBuffer> GetIndexBuffer(size_t at) const override {	8✔
511	return {new hkxIndexBufferMidInterface(**interface.IndexBuffers().Next(at)),	8✔
512	true};	8✔
513	}
514
NEW 515	const hkxMaterial *Material() const override {	×
NEW 516	return *header->GetClass(interface.Material().data);	×
517	}
518
NEW 519	size_t GetNumUserChannels() const override {	×
NEW 520	return interface.NumUserChannels();	×
521	}
522
NEW 523	const IhkVirtualClass *GetUserChannel(size_t at) const override {	×
NEW 524	return header->GetClass(interface.UserChannels().Next(at).Object());	×
525	}
526
NEW 527	size_t GetNumVertexAnimations() const override {	×
NEW 528	return interface.NumVertexAnimations();	×
529	}
530
531	uni::Element<hkxVertexAnimation>
NEW 532	GetVertexAnimation(size_t at) const override {	×
533	return {new hkxVertexAnimationMidInterface(
NEW 534	**interface.VertexAnimations().Next(at)),	×
NEW 535	true};	×
536	}
537
NEW 538	std::span<const float> LinearKeyFrameHints() const override {	×
539	return {interface.LinearKeyFrameHints(),
NEW 540	interface.NumLinearKeyFrameHints()};	×
541	}
542
NEW 543	size_t NumBoneMatrixMaps() const override {	×
NEW 544	return interface.NumBoneMatrixMap();	×
545	}
546
NEW 547	std::span<const int16> BoneMatrixMapping(size_t at) const override {	×
NEW 548	return {interface.BoneMatrixMap().Next(at).Mapping(),	×
NEW 549	interface.BoneMatrixMap().Next(at).NumMapping()};	×
550	}
551	};
552
553	struct hkxMeshMidInterface : hkxMeshInternalInterface {
554	clgen::hkxMesh::Interface interface;
555
556	hkxMeshMidInterface(clgen::LayoutLookup rules, char *data)	64✔
557	: interface{data, rules} {}	64✔
558	hkxMeshMidInterface(const clgen::hkxMesh::Interface &interface)
NEW 559	: interface{interface} {}	×
560
561	void SetDataPointer(void *ptr) override {	64✔
562	interface.data = static_cast<char *>(ptr);	64✔
563	}	64✔
564
565	const void *GetPointer() const override { return interface.data; }	40✔
566
567	void SwapEndian() override { clgen::EndianSwap(interface); }	32✔
568
569	size_t GetNumSections() const override { return interface.NumSections(); }	16✔
570
571	uni::Element<const hkxMeshSection> GetSection(size_t at) const override {	8✔
572	return {
573	new hkxMeshSectionMidInterface(**interface.Sections().Next(at), header),	8✔
574	true};	8✔
575	}
576
577	size_t GetNumUserChannelInfos() const override {	8✔
578	return interface.NumUserChannelInfos();	8✔
579	}
580
NEW 581	hkxMeshUserChannelInfo GetUserChannelInfo(size_t at) const override {	×
NEW 582	auto info = interface.UserChannelInfos().Next(at);	×
583
584	return {
585	.name = info.Name(),
586	.className = info.ClassName(),
587	};
588	}
589	};
590
NEW 591	hkxMeshInternalInterface hkxMeshInternalInterface::Create(void interface) {	×
592	return new hkxMeshMidInterface(
NEW 593	static_cast<clgen::hkxMesh::Interface >(interface));	×
594	}
595
596	CREATE_HK_CLASS(hkxMesh);	4✔
NEW 597	CREATE_HK_CLASS(hkxVertexBuffer);	×
598	CREATE_HK_CLASS(hkxIndexBuffer);	4✔
599	CREATE_HK_CLASS(hkxMeshSection);	4✔
NEW 600	CREATE_HK_CLASS(hkxVertexDescription);	×

PredatorCZ / HavokLib / 90

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous