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

68.37

/source/packfile/hkx_scene.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_scene.hpp"
#include "base.hpp"
#include "hkx_attribute_holder.hpp"

struct hkMatrix3 {
  Vector4A16 r0;
  Vector4A16 r1;
  Vector4A16 r2;
};

#include "hkx_scene.inl"

template <> void FByteswapper(hkxCamera &item, bool) {
  FByteswapper(item.from);
  FByteswapper(item.focus);
  FByteswapper(item.up);
  FByteswapper(item.fov);
  FByteswapper(item.far);
  FByteswapper(item.near);
}

struct hkxNodeMidInterface : hkxNodeInternalInterface,
                             hkxAttributeHolderMidInterface {
  clgen::hkxNode::Interface interface;

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

  hkxNodeMidInterface(const clgen::hkxNode::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 {
    hkxAttributeHolderMidInterface::SwapEndian();
    clgen::EndianSwap(interface);
    es::Matrix44 *keyFrames = interface.KeyFrames();
    const uint32 numKeyFrames = interface.NumKeyFrames();

    for (uint32 i = 0; i < numKeyFrames; i++) {
      FByteswapper(keyFrames[i]);
    }

    auto annotations = interface.Annotations();
    uint32 numAnnotations = interface.NumAnnotations();

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

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

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

  clgen::hkxAttributeHolder::Interface AttribHolder() const override {
    return interface.BasehkxAttributeHolder();
  }

  std::string_view Name() const override { return safe_sw(interface.Name()); }

  const IhkVirtualClass *Object() const override {
    return header->GetClass(interface.Object().Object());
  }

  std::span<const es::Matrix44> KeyFrames() const override {
    return {interface.KeyFrames(), interface.NumKeyFrames()};
  }

  size_t GetNumChildren() const override { return interface.NumChildren(); }

  uni::Element<const hkxNode> GetChild(size_t at) const override {
    return {new hkxNodeMidInterface(**interface.Children().Next(at)), true};
  }

  size_t GetNumAnnotations() const override {
    return interface.NumAnnotations();
  }

  hkxNodeAnnotationData GetAnnotation(size_t at) const override {
    auto annotation = interface.Annotations().Next(at);
    return hkxNodeAnnotationData{
        .time = annotation.Time(),
        .description = annotation.Description(),
    };
  }

  std::string_view UserProperties() const override {
    return safe_sw(interface.UserProperties());
  }

  bool Selected() const override { return interface.Selected(); }
};

struct hkxNodeSelectionSetMidInterface : hkxNodeSelectionSetInternalInterface,
                                         hkxAttributeHolderMidInterface {
  clgen::hkxNodeSelectionSet::Interface interface;

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

  hkxNodeSelectionSetMidInterface(
      const clgen::hkxNodeSelectionSet::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 {
    hkxAttributeHolderMidInterface::SwapEndian();
    clgen::EndianSwap(interface);
  }

  clgen::hkxAttributeHolder::Interface AttribHolder() const override {
    return interface.BasehkxAttributeHolder();
  }

  size_t GetNumSelectedNodes() const override {
    return interface.NumSelectedNodes();
  }

  uni::Element<const hkxNode> GetSelectedNode(size_t at) const override {
    return {new hkxNodeMidInterface(**interface.SelectedNodes().Next(at)),
            true};
  }

  std::string_view Name() const override { return safe_sw(interface.Name()); }
};

struct hkxLightMidInterface : hkxLightInternalInterface {
  clgen::hkxLight::Interface interface;

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

  hkxLightMidInterface(const clgen::hkxLight::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); }

  LightType GetLightType() const override { return interface.Type(); }

  Vector4A16 Position() const override { return interface.Position(); }

  Vector4A16 Direction() const override { return interface.Direction(); }

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

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

struct hkxTextureInplaceMidInterface : hkxTextureInplaceInternalInterface {
  clgen::hkxTextureInplace::Interface interface;

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

  hkxTextureInplaceMidInterface(
      const clgen::hkxTextureInplace::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); }

  std::string_view FileType() const override {
    auto ftype = interface.FileType();
    return {ftype.data(), ftype.size()};
  }

  size_t DataSize() const override { return interface.NumData_(); }

  const char *Data() const override {
    return reinterpret_cast<const char *>(interface.Data_());
  }

  std::string_view Name() const override { return safe_sw(interface.Name()); }

  std::string_view OriginalFilename() const override {
    return safe_sw(interface.OriginalFilename());
  }
};

struct hkxTextureFileMidInterface : hkxTextureFileInternalInterface {
  clgen::hkxTextureFile::Interface interface;

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

  hkxTextureFileMidInterface(const clgen::hkxTextureFile::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); }

  std::string_view FileName() const override {
    return safe_sw(interface.FileName());
  }

  std::string_view Name() const override { return safe_sw(interface.Name()); }

  std::string_view OriginalFilename() const override {
    return safe_sw(interface.OriginalFilename());
  }
};

struct hkxSkinBindingMidInterface : hkxSkinBindingInternalInterface {
  clgen::hkxSkinBinding::Interface interface;

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

  hkxSkinBindingMidInterface(const clgen::hkxSkinBinding::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);
    es::Matrix44 *skins = interface.BindPose();
    uint32 numSkins = interface.NumBindPose();

    for (uint32 i = 0; i < numSkins; i++) {
      FByteswapper(skins[i]);
    }

    es::Matrix44 initPose = interface.InitSkinTransform();
    FByteswapper(initPose);
    interface.InitSkinTransform(initPose);
  }

  const hkxMesh *Mesh() const override {
    return safe_deref_cast<const hkxMesh>(
        header->GetClass(interface.Mesh().data));
  }

  size_t GetNumMappings() const override { return interface.NumMapping(); }

  uni::Element<const hkxNode> GetMapping(size_t at) const override {
    return {new hkxNodeMidInterface(**interface.Mapping().Next(at)), true};
  }

  std::span<const es::Matrix44> BindPoses() const override {
    return {interface.BindPose(), interface.NumBindPose()};
  }

  es::Matrix44 InitSkinTransform() const override {
    return interface.InitSkinTransform();
  }
};

struct hkxCameraMidInterface : hkxCameraInternalInterface {
  clgen::hkxCamera::Interface interface;

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

  hkxCameraMidInterface(const clgen::hkxCamera::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);
    FByteswapper(*interface.Data_().data());
  }
};

struct hkxSceneMidInterface : hkxSceneInternalInterface {
  clgen::hkxScene::Interface interface;

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

  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 tm = interface.AppliedTransform();
    FByteswapper(tm.r0);
    FByteswapper(tm.r1);
    FByteswapper(tm.r2);
    interface.AppliedTransform(tm);
  }

  std::string_view Modeller() const override {
    return safe_sw(interface.Modeller());
  }

  std::string_view Asset() const override { return safe_sw(interface.Asset()); }

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

  uni::Element<const hkxNode> RootNode() const override {
    return {new hkxNodeMidInterface(*interface.RootNode()), true};
  }

  size_t GetNumSelectionSets() const override {
    return interface.NumSelectionSets();
  }

  uni::Element<const hkxNodeSelectionSet>
  GetSelectionSet(size_t at) const override {
    return {new hkxNodeSelectionSetMidInterface(
                **interface.SelectionSets().Next(at)),
            true};
  }

  size_t GetNumCameras() const override { return interface.NumCameras(); }

  const hkxCamera *GetCamera(size_t at) const override {
    return (**interface.Cameras().Next(at)).Data_().data();
  }

  size_t GetNumLights() const override { return interface.NumLights(); }

  uni::Element<const hkxLight> GetLight(size_t at) const override {
    return {new hkxLightMidInterface(**interface.Lights().Next(at)), true};
  }

  size_t GetNumMaterials() const override { return interface.NumMaterials(); }

  const hkxMaterial *GetMaterial(size_t at) const override {
    return safe_deref_cast<const hkxMaterial>(
        header->GetClass((**interface.Materials().Next(at)).data));
  }

  size_t GetNumMeshes() const override { return interface.NumMeshes(); }

  const hkxMesh *GetMesh(size_t at) const override {
    return safe_deref_cast<const hkxMesh>(
        header->GetClass((**interface.Meshes().Next(at)).data));
  }

  size_t GetNumInplaceTextures() const override {
    return interface.NumInplaceTextures();
  }

  uni::Element<const hkxTextureInplace>
  GetInplaceTexture(size_t at) const override {
    return {new hkxTextureInplaceMidInterface(
                **interface.InplaceTextures().Next(at)),
            true};
  }

  size_t GetNumExternalTextures() const override {
    return interface.NumExternalTextures();
  }

  uni::Element<const hkxTextureFile>
  GetExternalTexture(size_t at) const override {
    return {
        new hkxTextureFileMidInterface(**interface.ExternalTextures().Next(at)),
        true};
  }

  size_t GetNumSkinBindings() const override {
    return interface.NumSkinBindings();
  }

  uni::Element<const hkxSkinBinding> GetSkinBinding(size_t at) const override {
    return {new hkxSkinBindingMidInterface(**interface.SkinBindings().Next(at)),
            true};
  }

  es::Matrix44 AppliedTransform() const override {
    hkMatrix3 atm = interface.AppliedTransform();
    return es::Matrix44(atm.r0, atm.r1, atm.r2);
  }
};

CREATE_HK_CLASS(hkxScene);
CREATE_HK_CLASS(hkxLight);
CREATE_HK_CLASS(hkxNode);
CREATE_HK_CLASS(hkxCamera);
CREATE_HK_CLASS(hkxNodeSelectionSet);
CREATE_HK_CLASS(hkxSkinBinding);
CREATE_HK_CLASS(hkxTextureFile);
CREATE_HK_CLASS(hkxTextureInplace);

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_scene.hpp"
19	#include "base.hpp"
20	#include "hkx_attribute_holder.hpp"
21
22	struct hkMatrix3 {
23	Vector4A16 r0;
24	Vector4A16 r1;
25	Vector4A16 r2;
26	};
27
28	#include "hkx_scene.inl"
29
30	template <> void FByteswapper(hkxCamera &item, bool) {	32✔
31	FByteswapper(item.from);	32✔
32	FByteswapper(item.focus);	32✔
33	FByteswapper(item.up);	32✔
34	FByteswapper(item.fov);	32✔
35	FByteswapper(item.far);	32✔
36	FByteswapper(item.near);	32✔
37	}	32✔
38
39	struct hkxNodeMidInterface : hkxNodeInternalInterface,
40	hkxAttributeHolderMidInterface {
41	clgen::hkxNode::Interface interface;
42
43	hkxNodeMidInterface(clgen::LayoutLookup rules, char *data)	832✔
44	: interface{data, rules} {}	832✔
45
46	hkxNodeMidInterface(const clgen::hkxNode::Interface &interface)	104✔
47	: interface(interface) {}	104✔
48
49	void SetDataPointer(void *ptr) override {	832✔
50	interface.data = static_cast<char *>(ptr);	832✔
51	}	832✔
52
53	const void *GetPointer() const override { return interface.data; }	208✔
54
55	void SwapEndian() override {	416✔
56	hkxAttributeHolderMidInterface::SwapEndian();	416✔
57	clgen::EndianSwap(interface);	416✔
58	es::Matrix44 *keyFrames = interface.KeyFrames();
59	const uint32 numKeyFrames = interface.NumKeyFrames();
60
61	for (uint32 i = 0; i < numKeyFrames; i++) {	29,920✔
62	FByteswapper(keyFrames[i]);	29,504✔
63	}
64
65	auto annotations = interface.Annotations();	416✔
66	uint32 numAnnotations = interface.NumAnnotations();
67
68	for (uint32 i = 0; i < numAnnotations; i++, annotations.Next()) {	864✔
69	clgen::EndianSwap(annotations);	448✔
70	}
71
72	float *linearKFs = interface.LinearKeyFrameHints();
73	uint32 numLinearKFs = interface.NumLinearKeyFrameHints();
74
75	for (uint32 i = 0; i < numLinearKFs; i++) {	416✔
NEW 76	FByteswapper(linearKFs[i]);	×
77	}
78	}	416✔
79
80	clgen::hkxAttributeHolder::Interface AttribHolder() const override {	416✔
81	return interface.BasehkxAttributeHolder();	416✔
82	}
83
84	std::string_view Name() const override { return safe_sw(interface.Name()); }	200✔
85
NEW 86	const IhkVirtualClass *Object() const override {	×
NEW 87	return header->GetClass(interface.Object().Object());	×
88	}
89
90	std::span<const es::Matrix44> KeyFrames() const override {	104✔
91	return {interface.KeyFrames(), interface.NumKeyFrames()};	104✔
92	}
93
94	size_t GetNumChildren() const override { return interface.NumChildren(); }	208✔
95
96	uni::Element<const hkxNode> GetChild(size_t at) const override {	96✔
97	return {new hkxNodeMidInterface(**interface.Children().Next(at)), true};	96✔
98	}
99
100	size_t GetNumAnnotations() const override {	208✔
101	return interface.NumAnnotations();	208✔
102	}
103
104	hkxNodeAnnotationData GetAnnotation(size_t at) const override {	112✔
105	auto annotation = interface.Annotations().Next(at);	112✔
106	return hkxNodeAnnotationData{
107	.time = annotation.Time(),
108	.description = annotation.Description(),
109	};	112✔
110	}
111
NEW 112	std::string_view UserProperties() const override {	×
NEW 113	return safe_sw(interface.UserProperties());	×
114	}
115
116	bool Selected() const override { return interface.Selected(); }	104✔
117	};
118
119	struct hkxNodeSelectionSetMidInterface : hkxNodeSelectionSetInternalInterface,
120	hkxAttributeHolderMidInterface {
121	clgen::hkxNodeSelectionSet::Interface interface;
122
NEW 123	hkxNodeSelectionSetMidInterface(clgen::LayoutLookup rules, char *data)	×
NEW 124	: interface{data, rules} {}	×
125
NEW 126	hkxNodeSelectionSetMidInterface(	×
127	const clgen::hkxNodeSelectionSet::Interface &interface)
NEW 128	: interface(interface) {}	×
129
NEW 130	void SetDataPointer(void *ptr) override {	×
NEW 131	interface.data = static_cast<char *>(ptr);	×
132	}
133
NEW 134	const void *GetPointer() const override { return interface.data; }	×
135
NEW 136	void SwapEndian() override {	×
NEW 137	hkxAttributeHolderMidInterface::SwapEndian();	×
NEW 138	clgen::EndianSwap(interface);	×
139	}
140
NEW 141	clgen::hkxAttributeHolder::Interface AttribHolder() const override {	×
NEW 142	return interface.BasehkxAttributeHolder();	×
143	}
144
NEW 145	size_t GetNumSelectedNodes() const override {	×
NEW 146	return interface.NumSelectedNodes();	×
147	}
148
NEW 149	uni::Element<const hkxNode> GetSelectedNode(size_t at) const override {	×
NEW 150	return {new hkxNodeMidInterface(**interface.SelectedNodes().Next(at)),	×
NEW 151	true};	×
152	}
153
NEW 154	std::string_view Name() const override { return safe_sw(interface.Name()); }	×
155	};
156
157	struct hkxLightMidInterface : hkxLightInternalInterface {
158	clgen::hkxLight::Interface interface;
159
160	hkxLightMidInterface(clgen::LayoutLookup rules, char *data)	192✔
161	: interface{data, rules} {}	192✔
162
163	hkxLightMidInterface(const clgen::hkxLight::Interface &interface)
164	: interface(interface) {}	8✔
165
166	void SetDataPointer(void *ptr) override {	192✔
167	interface.data = static_cast<char *>(ptr);	192✔
168	}	192✔
169
170	const void *GetPointer() const override { return interface.data; }	48✔
171
172	void SwapEndian() override { clgen::EndianSwap(interface); }	96✔
173
NEW 174	LightType GetLightType() const override { return interface.Type(); }	×
175
NEW 176	Vector4A16 Position() const override { return interface.Position(); }	×
177
NEW 178	Vector4A16 Direction() const override { return interface.Direction(); }	×
179
NEW 180	uint32 Color() const override { return interface.Color(); }	×
181
NEW 182	float Angle() const override { return interface.Angle(); }	×
183	};
184
185	struct hkxTextureInplaceMidInterface : hkxTextureInplaceInternalInterface {
186	clgen::hkxTextureInplace::Interface interface;
187
188	hkxTextureInplaceMidInterface(clgen::LayoutLookup rules, char *data)	64✔
189	: interface{data, rules} {}	64✔
190
191	hkxTextureInplaceMidInterface(
192	const clgen::hkxTextureInplace::Interface &interface)
193	: interface(interface) {}	8✔
194
195	void SetDataPointer(void *ptr) override {	64✔
196	interface.data = static_cast<char *>(ptr);	64✔
197	}	64✔
198
199	const void *GetPointer() const override { return interface.data; }	16✔
200
201	void SwapEndian() override { clgen::EndianSwap(interface); }	32✔
202
NEW 203	std::string_view FileType() const override {	×
204	auto ftype = interface.FileType();
NEW 205	return {ftype.data(), ftype.size()};	×
206	}
207
NEW 208	size_t DataSize() const override { return interface.NumData_(); }	×
209
NEW 210	const char *Data() const override {	×
NEW 211	return reinterpret_cast<const char *>(interface.Data_());	×
212	}
213
NEW 214	std::string_view Name() const override { return safe_sw(interface.Name()); }	×
215
NEW 216	std::string_view OriginalFilename() const override {	×
NEW 217	return safe_sw(interface.OriginalFilename());	×
218	}
219	};
220
221	struct hkxTextureFileMidInterface : hkxTextureFileInternalInterface {
222	clgen::hkxTextureFile::Interface interface;
223
224	hkxTextureFileMidInterface(clgen::LayoutLookup rules, char *data)	64✔
225	: interface{data, rules} {}	64✔
226
227	hkxTextureFileMidInterface(const clgen::hkxTextureFile::Interface &interface)
228	: interface(interface) {}	8✔
229
230	void SetDataPointer(void *ptr) override {	64✔
231	interface.data = static_cast<char *>(ptr);	64✔
232	}	64✔
233
234	const void *GetPointer() const override { return interface.data; }	8✔
235
236	void SwapEndian() override { clgen::EndianSwap(interface); }	32✔
237
NEW 238	std::string_view FileName() const override {	×
NEW 239	return safe_sw(interface.FileName());	×
240	}
241
NEW 242	std::string_view Name() const override { return safe_sw(interface.Name()); }	×
243
NEW 244	std::string_view OriginalFilename() const override {	×
NEW 245	return safe_sw(interface.OriginalFilename());	×
246	}
247	};
248
249	struct hkxSkinBindingMidInterface : hkxSkinBindingInternalInterface {
250	clgen::hkxSkinBinding::Interface interface;
251
252	hkxSkinBindingMidInterface(clgen::LayoutLookup rules, char *data)	64✔
253	: interface{data, rules} {}	64✔
254
255	hkxSkinBindingMidInterface(const clgen::hkxSkinBinding::Interface &interface)
256	: interface(interface) {}	8✔
257
258	void SetDataPointer(void *ptr) override {	64✔
259	interface.data = static_cast<char *>(ptr);	64✔
260	}	64✔
261
262	const void *GetPointer() const override { return interface.data; }	8✔
263
264	void SwapEndian() override {	32✔
265	clgen::EndianSwap(interface);	32✔
266	es::Matrix44 *skins = interface.BindPose();
267	uint32 numSkins = interface.NumBindPose();
268
269	for (uint32 i = 0; i < numSkins; i++) {	256✔
270	FByteswapper(skins[i]);	224✔
271	}
272
273	es::Matrix44 initPose = interface.InitSkinTransform();	32✔
274	FByteswapper(initPose);
275	interface.InitSkinTransform(initPose);	32✔
276	}	32✔
277
NEW 278	const hkxMesh *Mesh() const override {	×
NEW 279	return safe_deref_cast<const hkxMesh>(	×
NEW 280	header->GetClass(interface.Mesh().data));	×
281	}
282
NEW 283	size_t GetNumMappings() const override { return interface.NumMapping(); }	×
284
NEW 285	uni::Element<const hkxNode> GetMapping(size_t at) const override {	×
NEW 286	return {new hkxNodeMidInterface(**interface.Mapping().Next(at)), true};	×
287	}
288
NEW 289	std::span<const es::Matrix44> BindPoses() const override {	×
NEW 290	return {interface.BindPose(), interface.NumBindPose()};	×
291	}
292
NEW 293	es::Matrix44 InitSkinTransform() const override {	×
NEW 294	return interface.InitSkinTransform();	×
295	}
296	};
297
298	struct hkxCameraMidInterface : hkxCameraInternalInterface {
299	clgen::hkxCamera::Interface interface;
300
301	hkxCameraMidInterface(clgen::LayoutLookup rules, char *data)	64✔
302	: interface{data, rules} {}	64✔
303
304	hkxCameraMidInterface(const clgen::hkxCamera::Interface &interface)
305	: interface(interface) {}
306
307	void SetDataPointer(void *ptr) override {	64✔
308	interface.data = static_cast<char *>(ptr);	64✔
309	}	64✔
310
311	const void *GetPointer() const override { return interface.data; }	16✔
312
313	void SwapEndian() override {	32✔
314	clgen::EndianSwap(interface);	32✔
315	FByteswapper(*interface.Data_().data());	32✔
316	}	32✔
317	};
318
319	struct hkxSceneMidInterface : hkxSceneInternalInterface {
320	clgen::hkxScene::Interface interface;
321
322	hkxSceneMidInterface(clgen::LayoutLookup rules, char *data)	64✔
323	: interface{data, rules} {}	64✔
324
325	void SetDataPointer(void *ptr) override {	64✔
326	interface.data = static_cast<char *>(ptr);	64✔
327	}	64✔
328
329	const void *GetPointer() const override { return interface.data; }	24✔
330
331	void SwapEndian() override {	32✔
332	clgen::EndianSwap(interface);	32✔
333	auto tm = interface.AppliedTransform();
334	FByteswapper(tm.r0);
335	FByteswapper(tm.r1);
336	FByteswapper(tm.r2);
337	interface.AppliedTransform(tm);	32✔
338	}	32✔
339
NEW 340	std::string_view Modeller() const override {	×
NEW 341	return safe_sw(interface.Modeller());	×
342	}
343
NEW 344	std::string_view Asset() const override { return safe_sw(interface.Asset()); }	×
345
NEW 346	float SceneLength() const override { return interface.SceneLength(); }	×
347
348	uni::Element<const hkxNode> RootNode() const override {	8✔
349	return {new hkxNodeMidInterface(*interface.RootNode()), true};	8✔
350	}
351
352	size_t GetNumSelectionSets() const override {	8✔
353	return interface.NumSelectionSets();	8✔
354	}
355
356	uni::Element<const hkxNodeSelectionSet>
NEW 357	GetSelectionSet(size_t at) const override {	×
358	return {new hkxNodeSelectionSetMidInterface(
NEW 359	**interface.SelectionSets().Next(at)),	×
NEW 360	true};	×
361	}
362
363	size_t GetNumCameras() const override { return interface.NumCameras(); }	16✔
364
365	const hkxCamera *GetCamera(size_t at) const override {	8✔
366	return (**interface.Cameras().Next(at)).Data_().data();	8✔
367	}
368
369	size_t GetNumLights() const override { return interface.NumLights(); }	8✔
370
371	uni::Element<const hkxLight> GetLight(size_t at) const override {	8✔
372	return {new hkxLightMidInterface(**interface.Lights().Next(at)), true};	8✔
373	}
374
375	size_t GetNumMaterials() const override { return interface.NumMaterials(); }	8✔
376
377	const hkxMaterial *GetMaterial(size_t at) const override {	8✔
378	return safe_deref_cast<const hkxMaterial>(	8✔
379	header->GetClass((**interface.Materials().Next(at)).data));	8✔
380	}
381
382	size_t GetNumMeshes() const override { return interface.NumMeshes(); }	8✔
383
384	const hkxMesh *GetMesh(size_t at) const override {	8✔
385	return safe_deref_cast<const hkxMesh>(	8✔
386	header->GetClass((**interface.Meshes().Next(at)).data));	8✔
387	}
388
389	size_t GetNumInplaceTextures() const override {	8✔
390	return interface.NumInplaceTextures();	8✔
391	}
392
393	uni::Element<const hkxTextureInplace>
394	GetInplaceTexture(size_t at) const override {	8✔
395	return {new hkxTextureInplaceMidInterface(
396	**interface.InplaceTextures().Next(at)),	8✔
397	true};	8✔
398	}
399
400	size_t GetNumExternalTextures() const override {	8✔
401	return interface.NumExternalTextures();	8✔
402	}
403
404	uni::Element<const hkxTextureFile>
405	GetExternalTexture(size_t at) const override {	8✔
406	return {
407	new hkxTextureFileMidInterface(**interface.ExternalTextures().Next(at)),	8✔
408	true};	8✔
409	}
410
411	size_t GetNumSkinBindings() const override {	8✔
412	return interface.NumSkinBindings();	8✔
413	}
414
415	uni::Element<const hkxSkinBinding> GetSkinBinding(size_t at) const override {	8✔
416	return {new hkxSkinBindingMidInterface(**interface.SkinBindings().Next(at)),	8✔
417	true};	8✔
418	}
419
NEW 420	es::Matrix44 AppliedTransform() const override {	×
421	hkMatrix3 atm = interface.AppliedTransform();
NEW 422	return es::Matrix44(atm.r0, atm.r1, atm.r2);	×
423	}
424	};
425
426	CREATE_HK_CLASS(hkxScene);	4✔
NEW 427	CREATE_HK_CLASS(hkxLight);	×
428	CREATE_HK_CLASS(hkxNode);	4✔
429	CREATE_HK_CLASS(hkxCamera);	4✔
NEW 430	CREATE_HK_CLASS(hkxNodeSelectionSet);	×
431	CREATE_HK_CLASS(hkxSkinBinding);	4✔
432	CREATE_HK_CLASS(hkxTextureFile);	4✔
NEW 433	CREATE_HK_CLASS(hkxTextureInplace);	×

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