refactor(Object): map shared_ptr to C-API

GothicKit · Jan 5, 2024 · 125f2b9 · 125f2b9
1 parent ff71049
commit 125f2b9
Show file tree

Hide file tree

Showing 24 changed files with 685 additions and 506 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -48,6 +48,7 @@ list(APPEND _ZKC_SOURCES
         src/ModelScript.cc
         src/MorphMesh.cc
         src/MultiResolutionMesh.cc
+        src/Object.cc
         src/SoftSkinMesh.cc
         src/Stream.cc
         src/Texture.cc

diff --git a/include/zenkit-capi/ModelAnimation.h b/include/zenkit-capi/ModelAnimation.h
@@ -25,7 +25,7 @@ typedef struct ZkInternal_AnimationSample {
 #endif
 } ZkAnimationSample;
 
-typedef ZkBool (*ZkAnimationSampleEnumerator)(void* ctx, ZkAnimationSample* sample);
+typedef ZkBool (*ZkAnimationSampleEnumerator)(void* ctx, ZkAnimationSample sample);
 
 ZKC_API ZkModelAnimation* ZkModelAnimation_load(ZkRead* buf);
 ZKC_API ZkModelAnimation* ZkModelAnimation_loadPath(ZkString path);

diff --git a/include/zenkit-capi/Object.h b/include/zenkit-capi/Object.h
@@ -0,0 +1,18 @@
+#pragma once
+#include "Library.h"
+
+#ifdef __cplusplus
+	#include <zenkit/Object.hh>
+
+	#include <memory>
+
+template <typename T>
+using ZkSharedHandle = std::shared_ptr<T>;
+using ZkObject = ZkSharedHandle<zenkit::Object>;
+
+#else
+typedef struct ZkInternal_SharedHandle ZkSharedHandle;
+typedef struct ZkInternal_Object ZkObject;
+#endif
+
+ZKC_API ZkObject* ZkObject_takeRef(ZkObject* slf);
diff --git a/include/zenkit-capi/World.h b/include/zenkit-capi/World.h
@@ -4,14 +4,15 @@
 #include "Library.h"
 #include "Mesh.h"
 #include "Stream.h"
+#include "Object.h"
 #include "Vfs.h"
 #include "vobs/VirtualObject.h"
 #include "world/BspTree.h"
 #include "world/WayNet.h"
 
 #ifdef __cplusplus
 	#include <zenkit/World.hh>
-using ZkWorld = zenkit::World;
+using ZkWorld = ZkSharedHandle<zenkit::World>;
 #else
 typedef struct ZkInternal_World ZkWorld;
 #endif

diff --git a/include/zenkit-capi/vobs/Camera.h b/include/zenkit-capi/vobs/Camera.h
@@ -5,12 +5,13 @@
 #include "../Library.h"
 #include "../Material.h"
 #include "../Matrix.h"
+#include "../Object.h"
 #include "../Vector.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Camera.hh>
-using ZkCutsceneCamera = zenkit::VCutsceneCamera;
-using ZkCameraTrajectoryFrame = zenkit::VCameraTrajectoryFrame;
+using ZkCutsceneCamera = ZkSharedHandle<zenkit::VCutsceneCamera>;
+using ZkCameraTrajectoryFrame = ZkSharedHandle<zenkit::VCameraTrajectoryFrame>;
 #else
 typedef struct ZkInternal_CutsceneCamera ZkCutsceneCamera;
 typedef struct ZkInternal_CameraTrajectoryFrame ZkCameraTrajectoryFrame;
@@ -80,12 +81,20 @@ ZKC_API float ZkCutsceneCamera_getAutoUntriggerLastDelay(ZkCutsceneCamera const*
 ZKC_API void ZkCutsceneCamera_setAutoUntriggerLastDelay(ZkCutsceneCamera* slf, float autoUntriggerLastDelay);
 ZKC_API int32_t ZkCutsceneCamera_getPositionCount(ZkCutsceneCamera const* slf);
 ZKC_API int32_t ZkCutsceneCamera_getTargetCount(ZkCutsceneCamera const* slf);
-ZKC_API void ZkCutsceneCamera_setTargetCount(ZkCutsceneCamera* slf, int32_t targetCount);
+ZKC_API ZkBool ZkCutsceneCamera_getIsPaused(ZkCutsceneCamera const* slf);
+ZKC_API void ZkCutsceneCamera_setIsPaused(ZkCutsceneCamera* slf, ZkBool isPaused);
+ZKC_API ZkBool ZkCutsceneCamera_getIsStarted(ZkCutsceneCamera const* slf);
+ZKC_API void ZkCutsceneCamera_setIsStarted(ZkCutsceneCamera* slf, ZkBool isStarted);
+ZKC_API ZkBool ZkCutsceneCamera_getGotoTimeMode(ZkCutsceneCamera const* slf);
+ZKC_API void ZkCutsceneCamera_setGotoTimeMode(ZkCutsceneCamera* slf, ZkBool gotoTimeMode);
+ZKC_API float ZkCutsceneCamera_getTime(ZkCutsceneCamera const* slf);
+ZKC_API void ZkCutsceneCamera_setTime(ZkCutsceneCamera* slf, float time);
 
 ZKC_API ZkSize ZkCutsceneCamera_getFrameCount(ZkCutsceneCamera const* slf);
 ZKC_API ZkCameraTrajectoryFrame* ZkCutsceneCamera_getFrame(ZkCutsceneCamera const* slf, ZkSize i);
 ZKC_API void
 ZkCutsceneCamera_enumerateFrames(ZkCutsceneCamera const* slf, ZkCameraTrajectoryFrameEnumerator cb, void* ctx);
+ZKC_API void ZkCameraTrajectoryFrame_del(ZkCameraTrajectoryFrame const* slf);
 
 ZKC_API float ZkCameraTrajectoryFrame_getTime(ZkCameraTrajectoryFrame const* slf);
 ZKC_API void ZkCameraTrajectoryFrame_setTime(ZkCameraTrajectoryFrame* slf, float time);

diff --git a/include/zenkit-capi/vobs/Light.h b/include/zenkit-capi/vobs/Light.h
@@ -3,11 +3,12 @@
 #pragma once
 #include "../Library.h"
 #include "../Material.h"
+#include "../Object.h"
 #include "../Vector.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Light.hh>
-using ZkLight = zenkit::VLight;
+using ZkLight = ZkSharedHandle<zenkit::VLight>;
 using ZkLightPreset = zenkit::LightPreset;
 #else
 typedef struct ZkInternal_Light ZkLight;

diff --git a/include/zenkit-capi/vobs/Misc.h b/include/zenkit-capi/vobs/Misc.h
@@ -3,19 +3,20 @@
 #pragma once
 #include "../Library.h"
 #include "../Material.h"
+#include "../Object.h"
 #include "../Vector.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Misc.hh>
-using ZkAnimate = zenkit::VAnimate;
-using ZkItem = zenkit::VItem;
-using ZkLensFlare = zenkit::VLensFlare;
-using ZkParticleEffectController = zenkit::VParticleEffectController;
-using ZkMessageFilter = zenkit::VMessageFilter;
-using ZkCodeMaster = zenkit::VCodeMaster;
-using ZkMoverController = zenkit::VMoverController;
-using ZkTouchDamage = zenkit::VTouchDamage;
-using ZkEarthquake = zenkit::VEarthquake;
+using ZkAnimate = ZkSharedHandle<zenkit::VAnimate>;
+using ZkItem = ZkSharedHandle<zenkit::VItem>;
+using ZkLensFlare = ZkSharedHandle<zenkit::VLensFlare>;
+using ZkParticleEffectController = ZkSharedHandle<zenkit::VParticleEffectController>;
+using ZkMessageFilter = ZkSharedHandle<zenkit::VMessageFilter>;
+using ZkCodeMaster = ZkSharedHandle<zenkit::VCodeMaster>;
+using ZkMoverController = ZkSharedHandle<zenkit::VMoverController>;
+using ZkTouchDamage = ZkSharedHandle<zenkit::VTouchDamage>;
+using ZkEarthquake = ZkSharedHandle<zenkit::VEarthquake>;
 #else
 typedef struct ZkInternal_Animate ZkAnimate;
 typedef struct ZkInternal_Item ZkItem;
@@ -55,12 +56,18 @@ ZKC_API ZkAnimate* ZkAnimate_loadPath(ZkString path, ZkGameVersion version);
 ZKC_API void ZkAnimate_del(ZkAnimate* slf);
 ZKC_API ZkBool ZkAnimate_getStartOn(ZkAnimate const* slf);
 ZKC_API void ZkAnimate_setStartOn(ZkAnimate* slf, ZkBool startOn);
+ZKC_API ZkBool ZkAnimate_getIsRunning(ZkAnimate const* slf);
+ZKC_API void ZkAnimate_setIsRunning(ZkAnimate* slf, ZkBool isRunning);
 
 ZKC_API ZkItem* ZkItem_load(ZkRead* buf, ZkGameVersion version);
 ZKC_API ZkItem* ZkItem_loadPath(ZkString path, ZkGameVersion version);
 ZKC_API void ZkItem_del(ZkItem* slf);
 ZKC_API ZkString ZkItem_getInstance(ZkItem const* slf);
 ZKC_API void ZkItem_setInstance(ZkItem* slf, ZkString instance);
+ZKC_API int ZkItem_getAmount(ZkItem const* slf);
+ZKC_API void ZkItem_setAmount(ZkItem* slf, int amount);
+ZKC_API int ZkItem_getFlags(ZkItem const* slf);
+ZKC_API void ZkItem_setFlags(ZkItem* slf, int flags);
 
 ZKC_API ZkLensFlare* ZkLensFlare_load(ZkRead* buf, ZkGameVersion version);
 ZKC_API ZkLensFlare* ZkLensFlare_loadPath(ZkString path, ZkGameVersion version);

diff --git a/include/zenkit-capi/vobs/MovableObject.h b/include/zenkit-capi/vobs/MovableObject.h
@@ -2,16 +2,18 @@
 // SPDX-License-Identifier: MIT
 #pragma once
 #include "../Library.h"
+#include "../Object.h"
 #include "../Stream.h"
 #include "../Vector.h"
+#include "Misc.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/MovableObject.hh>
-using ZkMovableObject = zenkit::VMovableObject;
-using ZkInteractiveObject = zenkit::VInteractiveObject;
-using ZkFire = zenkit::VFire;
-using ZkContainer = zenkit::VContainer;
-using ZkDoor = zenkit::VDoor;
+using ZkMovableObject = ZkSharedHandle<zenkit::VMovableObject>;
+using ZkInteractiveObject = ZkSharedHandle<zenkit::VInteractiveObject>;
+using ZkFire = ZkSharedHandle<zenkit::VFire>;
+using ZkContainer = ZkSharedHandle<zenkit::VContainer>;
+using ZkDoor = ZkSharedHandle<zenkit::VDoor>;
 #else
 typedef struct ZkInternal_MovableObject ZkMovableObject;
 typedef struct ZkInternal_InteractiveObject ZkInteractiveObject;
@@ -93,6 +95,12 @@ ZKC_API void ZkContainer_setPickString(ZkContainer* slf, ZkString pickString);
 ZKC_API ZkString ZkContainer_getContents(ZkContainer const* slf);
 ZKC_API void ZkContainer_setContents(ZkContainer* slf, ZkString contents);
 
+ZKC_API ZkSize ZkContainer_getItemCount(ZkContainer const* slf);
+ZKC_API ZkItem* ZkContainer_getItem(ZkContainer const* slf, ZkSize i);
+ZKC_API void ZkContainer_addItem(ZkContainer const* slf, ZkItem*);
+ZKC_API ZkItem* ZkContainer_addNewItem(ZkContainer const* slf);
+ZKC_API void ZkContainer_removeItem(ZkContainer const* slf);
+
 ZKC_API ZkDoor* ZkDoor_load(ZkRead* buf, ZkGameVersion version);
 ZKC_API ZkDoor* ZkDoor_loadPath(ZkString path, ZkGameVersion version);
 ZKC_API void ZkDoor_del(ZkDoor* slf);

diff --git a/include/zenkit-capi/vobs/Sound.h b/include/zenkit-capi/vobs/Sound.h
@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: MIT
 #pragma once
 #include "../Library.h"
+#include "../Object.h"
 #include "../Stream.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Sound.hh>
-using ZkSound = zenkit::VSound;
-using ZkSoundDaytime = zenkit::VSoundDaytime;
+using ZkSound = ZkSharedHandle<zenkit::VSound>;
+using ZkSoundDaytime = ZkSharedHandle<zenkit::VSoundDaytime>;
 #else
 typedef struct ZkInternal_Sound ZkSound;
 typedef struct ZkInternal_SoundDaytime ZkSoundDaytime;

diff --git a/include/zenkit-capi/vobs/Trigger.h b/include/zenkit-capi/vobs/Trigger.h
@@ -3,18 +3,19 @@
 #pragma once
 #include "../Library.h"
 #include "../ModelAnimation.h"
+#include "../Object.h"
 #include "../Stream.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Trigger.hh>
-using ZkTrigger = zenkit::VTrigger;
-using ZkMover = zenkit::VMover;
-using ZkTriggerList = zenkit::VTriggerList;
+using ZkTrigger = ZkSharedHandle<zenkit::VTrigger>;
+using ZkMover = ZkSharedHandle<zenkit::VMover>;
+using ZkTriggerList = ZkSharedHandle<zenkit::VTriggerList>;
 using ZkTriggerListTarget = zenkit::VTriggerList::Target;
-using ZkTriggerScript = zenkit::VTriggerScript;
-using ZkTriggerChangeLevel = zenkit::VTriggerChangeLevel;
-using ZkTriggerWorldStart = zenkit::VTriggerWorldStart;
-using ZkTriggerUntouch = zenkit::VTriggerUntouch;
+using ZkTriggerScript = ZkSharedHandle<zenkit::VTriggerScript>;
+using ZkTriggerChangeLevel = ZkSharedHandle<zenkit::VTriggerChangeLevel>;
+using ZkTriggerWorldStart = ZkSharedHandle<zenkit::VTriggerWorldStart>;
+using ZkTriggerUntouch = ZkSharedHandle<zenkit::VTriggerUntouch>;
 #else
 typedef struct ZkInternal_Trigger ZkTrigger;
 typedef struct ZkInternal_Mover ZkMover;

diff --git a/include/zenkit-capi/vobs/VirtualObject.h b/include/zenkit-capi/vobs/VirtualObject.h
@@ -5,13 +5,14 @@
 #include "../Library.h"
 #include "../Material.h"
 #include "../Matrix.h"
+#include "../Object.h"
 #include "../Vector.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/VirtualObject.hh>
-using ZkVirtualObject = zenkit::VirtualObject;
-using ZkVisual = zenkit::Visual;
-using ZkVisualDecal = zenkit::VisualDecal;
+using ZkVirtualObject = ZkSharedHandle<zenkit::VirtualObject>;
+using ZkVisual = ZkSharedHandle<zenkit::Visual>;
+using ZkVisualDecal = ZkSharedHandle<zenkit::VisualDecal>;
 #else
 typedef struct ZkInternal_VirtualObject ZkVirtualObject;
 typedef struct ZkInternal_Visual ZkVisual;
@@ -147,6 +148,7 @@ ZKC_API ZkVirtualObject* ZkVirtualObject_addChild(ZkVirtualObject* slf, ZkVobTyp
 ZKC_API void ZkVirtualObject_removeChild(ZkVirtualObject* slf, ZkSize i);
 ZKC_API void ZkVirtualObject_removeChildren(ZkVirtualObject* slf, ZkVirtualObjectEnumerator pred, void* ctx);
 
+ZKC_API void ZkVisual_del(ZkVisual* slf);
 ZKC_API ZkString ZkVisual_getName(ZkVisual const* slf);
 ZKC_API void ZkVisual_setName(ZkVisual* slf, ZkString name);
 ZKC_API ZkVisualType ZkVisual_getType(ZkVisual const* slf);

diff --git a/include/zenkit-capi/vobs/Zone.h b/include/zenkit-capi/vobs/Zone.h
@@ -1,17 +1,16 @@
 // Copyright © 2023. GothicKit Contributors
 // SPDX-License-Identifier: MIT
 #pragma once
-#include "../Boxes.h"
 #include "../Library.h"
-#include "../Matrix.h"
+#include "../Object.h"
 #include "../Stream.h"
 #include "../Vector.h"
 
 #ifdef __cplusplus
 	#include <zenkit/vobs/Zone.hh>
-using ZkZoneMusic = zenkit::VZoneMusic;
-using ZkZoneFarPlane = zenkit::VZoneFarPlane;
-using ZkZoneFog = zenkit::VZoneFog;
+using ZkZoneMusic = ZkSharedHandle<zenkit::VZoneMusic>;
+using ZkZoneFarPlane = ZkSharedHandle<zenkit::VZoneFarPlane>;
+using ZkZoneFog = ZkSharedHandle<zenkit::VZoneFog>;
 #else
 typedef struct ZkInternal_ZoneMusic ZkZoneMusic;
 typedef struct ZkInternal_ZoneFarPlane ZkZoneFarPlane;

diff --git a/src/Internal.hh b/src/Internal.hh
@@ -89,13 +89,8 @@
                                                                                                                        \
 		try {                                                                                                          \
 			auto ar = zenkit::ReadArchive::from(buf);                                                                  \
-                                                                                                                       \
-			zenkit::ArchiveObject o {};                                                                                \
-			ar->read_object_begin(o);                                                                                  \
-                                                                                                                       \
-			cls obj {};                                                                                                \
-			obj.load(*ar, static_cast<zenkit::GameVersion>(version));                                                  \
-			return ZKC_WRAP_NEW(obj);                                                                                  \
+			auto ob = ar->read_object<cls::element_type>(static_cast<zenkit::GameVersion>(version));                   \
+			return ZKC_WRAP_NEW(ob);                                                                                   \
 		} catch (std::exception const& exc) {                                                                          \
 			ZKC_LOG_ERROR(#cls "_load() failed: %s", exc.what());                                                      \
 			return nullptr;                                                                                            \
@@ -113,13 +108,8 @@
 		try {                                                                                                          \
 			auto buf = zenkit::Read::from(path);                                                                       \
 			auto ar = zenkit::ReadArchive::from(buf.get());                                                            \
-                                                                                                                       \
-			zenkit::ArchiveObject o {};                                                                                \
-			ar->read_object_begin(o);                                                                                  \
-                                                                                                                       \
-			cls obj {};                                                                                                \
-			obj.load(*ar, static_cast<zenkit::GameVersion>(version));                                                  \
-			return ZKC_WRAP_NEW(obj);                                                                                  \
+			auto ob = ar->read_object<cls::element_type>(static_cast<zenkit::GameVersion>(version));                   \
+			return ZKC_WRAP_NEW(ob);                                                                                   \
 		} catch (std::exception const& exc) {                                                                          \
 			ZKC_LOG_ERROR(#cls "_loadPath() failed: %s", exc.what());                                                  \
 			return nullptr;                                                                                            \
@@ -179,4 +169,5 @@ inline bool zk_any_nullptr(T*... args) {
 		}                                                                                                              \
 	} while (false)
 
-#define ZKC_TRACE_FN() //ZKC_LOG_TRACE("%s()", __func__)
+#define ZKC_TRACE_FN() // ZKC_LOG_TRACE("%s()", __func__)
+#define SLF (*slf)
diff --git a/src/ModelAnimation.cc b/src/ModelAnimation.cc
@@ -98,10 +98,8 @@ void ZkModelAnimation_enumerateSamples(ZkModelAnimation const* slf, ZkAnimationS
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULLV(slf, cb);
 
-	ZkAnimationSample as {};
 	for (auto& sample : slf->samples) {
-		as = sample;
-		if (cb(ctx, &as)) {
+		if (cb(ctx, sample)) {
 			break;
 		}
 	}

diff --git a/src/Object.cc b/src/Object.cc
@@ -0,0 +1,7 @@
+// Copyright © 2024. GothicKit Contributors
+// SPDX-License-Identifier: MIT
+#include "zenkit-capi/Object.h"
+
+ZkObject* ZkObject_takeRef(ZkObject* slf) {
+	return new ZkObject(*slf, slf->get());
+}
diff --git a/src/World.cc b/src/World.cc
@@ -4,47 +4,47 @@
 
 #include "Internal.hh"
 
-ZKC_LOADER(ZkWorld);
-ZKC_PATH_LOADER(ZkWorld);
+ZKC_VOB_LOADER(ZkWorld);
+ZKC_VOB_PATH_LOADER(ZkWorld);
 ZKC_VFS_LOADER(ZkWorld);
 ZKC_DELETER(ZkWorld);
 
 ZkMesh const* ZkWorld_getMesh(ZkWorld const* slf) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULL(slf);
-	return &slf->world_mesh;
+	return &SLF->world_mesh;
 }
 
 ZkWayNet const* ZkWorld_getWayNet(ZkWorld const* slf) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULL(slf);
-	return &slf->world_way_net;
+	return &SLF->world_way_net;
 }
 
 ZkBspTree const* ZkWorld_getBspTree(ZkWorld const* slf) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULL(slf);
-	return &slf->world_bsp_tree;
+	return &SLF->world_bsp_tree;
 }
 
 ZkSize ZkWorld_getRootObjectCount(ZkWorld const* slf) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULL(slf);
-	return slf->world_vobs.size();
+	return SLF->world_vobs.size();
 }
 
 ZkVirtualObject const* ZkWorld_getRootObject(ZkWorld const* slf, ZkSize i) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULL(slf);
-	ZKC_CHECK_LEN(slf->world_vobs, i);
-	return slf->world_vobs[i].get();
+	ZKC_CHECK_LEN(SLF->world_vobs, i);
+	return &SLF->world_vobs[i];
 }
 
 void ZkWorld_enumerateRootObjects(ZkWorld const* slf, ZkVirtualObjectEnumerator cb, void* ctx) {
 	ZKC_TRACE_FN();
 	ZKC_CHECK_NULLV(slf, cb);
 
-	for (auto& obj : slf->world_vobs) {
-		if (cb(ctx, obj.get())) break;
+	for (auto obj : SLF->world_vobs) {
+		if (cb(ctx, &obj)) break;
 	}
 }