deki-tiledmapeditor-integration/DekiTilemapModule.cpp at master · dekiengine/deki-tiledmapeditor-integration · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/**
 * @file DekiTilemapModule.cpp
 * @brief Module entry point for deki-tiledmap DLL
 */

#include "DekiTilemapModule.h"
#include "interop/DekiPlugin.h"
#include "DekiModuleFeatureMeta.h"
#include "TilemapComponent.h"
#include "TilemapColliderComponent.h"
#include "TilemapObjectSpawner.h"
#include "TilemapRenderSystem.h"
#include "reflection/ComponentRegistry.h"
#include "reflection/ComponentFactory.h"

#ifdef DEKI_EDITOR
#include "editor/TilemapSyncHandler.h"
#include "editor/TilemapInspector.h"
#endif

#ifdef DEKI_EDITOR

#ifndef DEKI_PLUGIN_EXPORTS
extern void DekiTilemap_RegisterComponents();
extern int  DekiTilemap_GetAutoComponentCount();
extern const DekiComponentMeta* DekiTilemap_GetAutoComponentMeta(int index);

static bool s_Registered = false;
#endif

extern "C" {

#ifndef DEKI_PLUGIN_EXPORTS
DEKI_TILEDMAP_API int DekiTilemap_EnsureRegistered(void)
{
    if (s_Registered)
        return DekiTilemap_GetAutoComponentCount();
    s_Registered = true;

    DekiTilemap_RegisterComponents();

    DekiTilemap::RegisterTilemapSyncHandlers();
    DekiTilemap::RegisterTilemapInspector();

    return DekiTilemap_GetAutoComponentCount();
}
#endif // DEKI_PLUGIN_EXPORTS

} // extern "C"

extern "C" {

#ifndef DEKI_PLUGIN_EXPORTS
DEKI_PLUGIN_API const char* DekiPlugin_GetName(void)
{
    return "Deki Tiled Map Module";
}

DEKI_PLUGIN_API const char* DekiPlugin_GetVersion(void)
{
#ifdef DEKI_MODULE_VERSION
    return DEKI_MODULE_VERSION;
#else
    return "0.0.0-dev";
#endif
}

DEKI_PLUGIN_API const char* DekiPlugin_GetReflectionJson(void)
{
    return "{}";
}

DEKI_PLUGIN_API int DekiPlugin_Init(void)
{
    return 0;
}

DEKI_PLUGIN_API void DekiPlugin_Shutdown(void)
{
    s_Registered = false;
}

DEKI_PLUGIN_API int DekiPlugin_GetComponentCount(void)
{
    return DekiTilemap_GetAutoComponentCount();
}

DEKI_PLUGIN_API const DekiComponentMeta* DekiPlugin_GetComponentMeta(int index)
{
    return DekiTilemap_GetAutoComponentMeta(index);
}

DEKI_PLUGIN_API void DekiPlugin_RegisterComponents(void)
{
    DekiTilemap_EnsureRegistered();
}
#endif // DEKI_PLUGIN_EXPORTS

// =============================================================================
// Module Feature API
// =============================================================================

static const char* s_RenderGuids[]    = { TilemapComponent::StaticGuid };
static const char* s_ColliderGuids[]  = { TilemapColliderComponent::StaticGuid };
static const char* s_ObjectGuids[]    = { TilemapObjectSpawner::StaticGuid };

static const DekiModuleFeatureInfo s_Features[] = {
    {"tilemap_render",    "Tilemap Rendering", "Render Tiled maps via batched quad blits",
        true, "DEKI_FEATURE_TILEMAP_RENDER",    s_RenderGuids,   1},
    {"tilemap_collision", "Tilemap Collision", "Per-tile collision shapes from tileset objectgroups",
        true, "DEKI_FEATURE_TILEMAP_COLLISION", s_ColliderGuids, 1},
    {"tilemap_objects",   "Object Layers",     "Spawn engine prefabs from Tiled object layers",
        true, "DEKI_FEATURE_TILEMAP_OBJECTS",   s_ObjectGuids,   1},
};

#ifndef DEKI_PLUGIN_EXPORTS
DEKI_PLUGIN_API int DekiPlugin_GetFeatureCount(void)
{
    return sizeof(s_Features) / sizeof(s_Features[0]);
}

DEKI_PLUGIN_API const DekiModuleFeatureInfo* DekiPlugin_GetFeature(int index)
{
    if (index < 0 || index >= DekiPlugin_GetFeatureCount())
        return nullptr;
    return &s_Features[index];
}
#endif // DEKI_PLUGIN_EXPORTS

// Module-specific feature API (linked-DLL access without name conflicts)

DEKI_TILEDMAP_API const char* DekiTilemap_GetName(void)
{
    return "Tiled Map";
}

DEKI_TILEDMAP_API int DekiTilemap_GetFeatureCount(void)
{
    return static_cast<int>(sizeof(s_Features) / sizeof(s_Features[0]));
}

DEKI_TILEDMAP_API const DekiModuleFeatureInfo* DekiTilemap_GetFeature(int index)
{
    if (index < 0 || index >= DekiTilemap_GetFeatureCount())
        return nullptr;
    return &s_Features[index];
}

} // extern "C"

#else // !DEKI_EDITOR — runtime-only build

// On non-editor targets, components register themselves via static
// initializers and there is no plugin export surface to expose.

#endif // DEKI_EDITOR