unity_native_sys 0.3.0

The raw FFI for the Unity Native Plugin API
Documentation 
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

// Unity Native Plugin API copyright © 2015 Unity Technologies ApS
//
// Licensed under the Unity Companion License for Unity - dependent projects--see[Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License).
//
// Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.Please review the license for details on these and other terms and conditions.

#pragma once
#include "IUnityInterface.h"
#include "IUnityProfiler.h"

#include <stdint.h>

// Unity Profiler Callbacks native plugin API provides an ability to register callbacks for Unity Profiler events.
// The basic functionality includes:
// 1. Profiler category creation callback - provides information about category name and color.
// 2. Profiler marker creation callback - provides information about new marker which is created internally or with C# API.
// 3. Marker event callback - allows to intercept begin/end events for the particular marker.
// 4. Frame event callback - provides information about logical CPU frame.
//
//  Usage example:
//
//  #include <IUnityInterface.h>
//  #include <IUnityProfilerCallbacks.h>
//
//  static IUnityProfilerCallbacks* s_UnityProfilerCallbacks = NULL;
//
//  static void UNITY_INTERFACE_API MyProfilerEventCallback(const UnityProfilerMarkerDesc* markerDesc, UnityProfilerMarkerEventType eventType, unsigned short eventDataCount, const UnityProfilerMarkerData* eventData, void* userData)
//  {
//      switch (eventType)
//      {
//          case kUnityProfilerMarkerEventTypeBegin:
//          {
//              MyProfilerPushMarker(markerDesc->name);
//              break;
//          }
//          case kUnityProfilerMarkerEventTypeEnd:
//          {
//              MyProfilerPopMarker(markerDesc->name);
//              break;
//          }
//      }
//  }
//
//  static void UNITY_INTERFACE_API MyProfilerCreateMarkerCallback(const UnityProfilerMarkerDesc* markerDesc, void* userData)
//  {
//      s_UnityProfilerCallbacks->RegisterMarkerEventCallback(markerDesc, MyProfilerEventCallback, NULL);
//  }
//
//  extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces)
//  {
//      s_UnityProfilerCallbacks = unityInterfaces->Get<IUnityProfilerCallbacks>();
//      s_UnityProfilerCallbacks->RegisterCreateMarkerCallback(&MyProfilerCreateMarkerCallback, NULL);
//  }
//
//  extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginUnload()
//  {
//      s_UnityProfilerCallbacks->UnregisterCreateMarkerCallback(&MyProfilerCreateMarkerCallback, NULL);
//      s_UnityProfilerCallbacks->UnregisterMarkerEventCallback(NULL, &MyProfilerEventCallback, NULL);
//  }

typedef struct UnityProfilerThreadDesc
{
    // Thread id c-casted to uint64_t.
    UnityProfilerThreadId threadId;
    // Thread group name. NULL-terminated.
    const char* groupName;
    // Thread name. NULL-terminated.
    const char* name;
} UnityProfilerThreadDesc;

// Called when a new category is created. Up to 4 installed callbacks are supported.
// \param categoryDesc is a pointer to category description.
// \param userData is an optional context pointer passed with RegisterCreateCategoryCallback call.
typedef void (UNITY_INTERFACE_API * IUnityProfilerCreateCategoryCallback)(const UnityProfilerCategoryDesc* categoryDesc, void* userData);

// Called when a new profiler marker is created. Up to 4 installed callbacks are supported.
// \param markerDesc is a pointer to marker description.
// \param userData is an optional context pointer passed with RegisterCreateEventCallback call.
typedef void (UNITY_INTERFACE_API * IUnityProfilerCreateMarkerCallback)(const UnityProfilerMarkerDesc* markerDesc, void* userData);

// Called when a profiler event occurs.
// \param markerDesc is an marker description struct.
// \param eventType is an event type - UnityProfilerMarkerEventType_.
// \param eventDataCount is an event metadata count.
// \param eventData is a metadata array of eventDataCount elements.
// \param userData is an optional context pointer passed with RegisterCreateEventCallback call.
typedef void (UNITY_INTERFACE_API* IUnityProfilerMarkerEventCallback)(const UnityProfilerMarkerDesc* markerDesc, UnityProfilerMarkerEventType eventType, uint16_t eventDataCount, const UnityProfilerMarkerData* eventData, void* userData);

typedef void (UNITY_INTERFACE_API * IUnityProfilerBulkCounterDataEventCallback)(int counterGroup, size_t size, void* data, void* userData);

// Called when a profiler frame change occurs. Up to 4 installed callbacks are supported.
// \param userData is an optional context pointer passed with RegisterCreateEventCallback call.
typedef void (UNITY_INTERFACE_API * IUnityProfilerFrameCallback)(void* userData);

// Called when a profiler frame change occurs. Up to 4 installed callbacks are supported.
// \param userData is an optional context pointer passed with RegisterCreateEventCallback call.
typedef void (UNITY_INTERFACE_API * IUnityProfilerThreadCallback)(const UnityProfilerThreadDesc* threadDesc, void* userData);

// Called when a profiler flow event occurs.
// Flow events connect events across threads allowing to trace related activities initiated from a control(main) thread.
// \param flowEventType is a flow event type.
// \param flowId is an unique incremental identifier for the flow chain.
// \param userData is an optional context pointer passed with RegisterCreateEventCallback call.
typedef void (UNITY_INTERFACE_API * IUnityProfilerFlowEventCallback)(UnityProfilerFlowEventType flowEventType, uint32_t flowId, void* userData);

// Available since 2019.1
UNITY_DECLARE_INTERFACE(IUnityProfilerCallbacksV2)
{
    // Register a callback which is called when a new category is created.
    // Returns 0 on success and non-zero in case of error.
    // Only up to 4 callbacks can be registered.
    int(UNITY_INTERFACE_API * RegisterCreateCategoryCallback)(IUnityProfilerCreateCategoryCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateCategoryCallback)(IUnityProfilerCreateCategoryCallback callback, void* userData);

    // Register a callback which is called when a new marker is created.
    // E.g. dynamically created in C# with "new PerformanceMarker(string)" or internally.
    // Also is called for all existing markers when the callback is registered.
    // Returns 0 on success and non-zero in case of error.
    // Only up to 4 callbacks can be registered.
    int(UNITY_INTERFACE_API * RegisterCreateMarkerCallback)(IUnityProfilerCreateMarkerCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateMarkerCallback)(IUnityProfilerCreateMarkerCallback callback, void* userData);

    // Register a callback which is called every time "PerformanceMarker.Begin(string)" is called or equivalent internal native counterpart.
    // Returns 0 on success and non-zero in case of error.
    // \param markerDesc is a pointer to marker description you want to install callback for.
    int(UNITY_INTERFACE_API * RegisterMarkerEventCallback)(const UnityProfilerMarkerDesc * markerDesc, IUnityProfilerMarkerEventCallback callback, void* userData);
    // Unregister per-marker callback.
    // \param markerDesc is a pointer to marker description you want to remove callback from.
    // \param userData optional context pointer.
    // If markerDesc is NULL, callback is removed from all events which have (callback, userData) pair.
    // If both markerDesc and userData are NULL, callback is removed from all events which have callback function pointer.
    int(UNITY_INTERFACE_API * UnregisterMarkerEventCallback)(const UnityProfilerMarkerDesc * markerDesc, IUnityProfilerMarkerEventCallback callback, void* userData);

    // Register a callback which is called every time Profiler.BeginSample is called or equivalent internal native counterpart.
    // Returns 0 on success and non-zero in case of error.
    // Only up to 4 callbacks can be registered.
    int(UNITY_INTERFACE_API * RegisterFrameCallback)(IUnityProfilerFrameCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterFrameCallback)(IUnityProfilerFrameCallback callback, void* userData);

    // Register a callback which is called every time a new thread is registered with profiler.
    // Returns 0 on success and non-zero in case of error.
    // Only up to 4 callbacks can be registered.
    int(UNITY_INTERFACE_API * RegisterCreateThreadCallback)(IUnityProfilerThreadCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateThreadCallback)(IUnityProfilerThreadCallback callback, void* userData);

    // Register a callback which is called every time Unity generates a flow event.
    // Returns 0 on success and non-zero in case of error.
    // Note: Flow events are supported only in Development Players and Editor.
    int(UNITY_INTERFACE_API * RegisterFlowEventCallback)(IUnityProfilerFlowEventCallback callback, void* userData);
    // Unregister flow event callback.
    // \param userData optional context pointer.
    int(UNITY_INTERFACE_API * UnregisterFlowEventCallback)(IUnityProfilerFlowEventCallback callback, void* userData);
};
UNITY_REGISTER_INTERFACE_GUID(0x5DEB59E88F2D4571ULL, 0x81E8583069A5E33CULL, IUnityProfilerCallbacksV2)

// Available since 2018.2
UNITY_DECLARE_INTERFACE(IUnityProfilerCallbacks)
{
    int(UNITY_INTERFACE_API * RegisterCreateCategoryCallback)(IUnityProfilerCreateCategoryCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateCategoryCallback)(IUnityProfilerCreateCategoryCallback callback, void* userData);

    int(UNITY_INTERFACE_API * RegisterCreateMarkerCallback)(IUnityProfilerCreateMarkerCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateMarkerCallback)(IUnityProfilerCreateMarkerCallback callback, void* userData);

    int(UNITY_INTERFACE_API * RegisterMarkerEventCallback)(const UnityProfilerMarkerDesc * markerDesc, IUnityProfilerMarkerEventCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterMarkerEventCallback)(const UnityProfilerMarkerDesc * markerDesc, IUnityProfilerMarkerEventCallback callback, void* userData);

    int(UNITY_INTERFACE_API * RegisterFrameCallback)(IUnityProfilerFrameCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterFrameCallback)(IUnityProfilerFrameCallback callback, void* userData);

    int(UNITY_INTERFACE_API * RegisterCreateThreadCallback)(IUnityProfilerThreadCallback callback, void* userData);
    int(UNITY_INTERFACE_API * UnregisterCreateThreadCallback)(IUnityProfilerThreadCallback callback, void* userData);
};
UNITY_REGISTER_INTERFACE_GUID(0x572FDB38CE3C4B1FULL, 0xA6071A9A7C4F52D8ULL, IUnityProfilerCallbacks)