deki-particles/DekiParticlesModule.cpp at master · dekiengine/deki-particles · 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 DekiParticlesModule.cpp
 * @brief Module entry point for deki-particles DLL
 *
 * Exports the standard Deki plugin interface so the editor can load
 * deki-particles.dll and register its components — the emitter plus all
 * built-in modifiers (Emission, Shape, InitialVelocity, InitialRotation,
 * Gravity, Drag, RotationOverLifetime, SizeOverLifetime, ColorOverLifetime).
 *
 * External particle modules ship the same way: declare a DEKI_COMPONENT
 * subclass of ParticleModifier, list it in your own module.json features,
 * and the emitter discovers it automatically via dynamic_cast on its
 * sibling components — no changes to deki-particles required.
 */

#include "interop/DekiPlugin.h"
#include "DekiModuleFeatureMeta.h"
#include "ParticleEmitterComponent.h"
#include "ParticleModifier.h"
#include "EmissionModifier.h"
#include "InitialVelocityModifier.h"
#include "InitialRotationModifier.h"
#include "GravityModifier.h"
#include "DragModifier.h"
#include "RotationOverLifetimeModifier.h"
#include "SizeOverLifetimeModifier.h"
#include "ColorOverLifetimeModifier.h"
#include "ParticleSystem.h"
#include "reflection/ComponentRegistry.h"
#include "reflection/ComponentFactory.h"
#ifdef DEKI_EDITOR
#include "imgui.h"
#endif

#ifdef DEKI_EDITOR

extern void DekiParticles_RegisterComponents();
extern int  DekiParticles_GetAutoComponentCount();
extern const DekiComponentMeta* DekiParticles_GetAutoComponentMeta(int index);

static bool s_ParticlesRegistered = false;

extern "C" {

DEKI_PARTICLES_API int DekiParticles_EnsureRegistered(void)
{
    if (s_ParticlesRegistered)
        return DekiParticles_GetAutoComponentCount();
    s_ParticlesRegistered = true;
    DekiParticles_RegisterComponents();
    return DekiParticles_GetAutoComponentCount();
}

DEKI_PLUGIN_API const char* DekiPlugin_GetName(void)
{
    return "Deki Particles 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_ParticlesRegistered = false;
    ParticleSystem::GetInstance().ClearAll();
}

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

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

DEKI_PLUGIN_API void DekiPlugin_RegisterComponents(void)
{
    DekiParticles_EnsureRegistered();
}

DEKI_PLUGIN_API void DekiPlugin_OnPlayModeStop(void)
{
    ParticleSystem::GetInstance().ClearAll();
}

#ifdef DEKI_EDITOR
DEKI_PLUGIN_API void DekiPlugin_SetImGuiContext(void* ctx)
{
    ImGui::SetCurrentContext(static_cast<ImGuiContext*>(ctx));
}
#endif

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

static const char* s_ParticleGuids[] = {
    ParticleEmitterComponent::StaticGuid,
    EmissionModifier::StaticGuid,
    InitialVelocityModifier::StaticGuid,
    InitialRotationModifier::StaticGuid,
    GravityModifier::StaticGuid,
    DragModifier::StaticGuid,
    RotationOverLifetimeModifier::StaticGuid,
    SizeOverLifetimeModifier::StaticGuid,
    ColorOverLifetimeModifier::StaticGuid,
};

static const DekiModuleFeatureInfo s_Features[] = {
    {
        "particle-emitter", "Particle Emitter",
        "Modular particle system: emitter plus built-in behavior modifiers",
        true, "DEKI_FEATURE_PARTICLE_EMITTER",
        s_ParticleGuids,
        sizeof(s_ParticleGuids) / sizeof(s_ParticleGuids[0])
    },
};

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];
}

// Module-specific feature API (for linked-DLL access without name conflicts)
DEKI_PARTICLES_API const char* DekiParticles_GetName(void)        { return "Particles"; }
DEKI_PARTICLES_API int DekiParticles_GetFeatureCount(void)        { return DekiPlugin_GetFeatureCount(); }
DEKI_PARTICLES_API const DekiModuleFeatureInfo* DekiParticles_GetFeature(int index) { return DekiPlugin_GetFeature(index); }

} // extern "C"

#endif // DEKI_EDITOR