少年修仙传客户端基础资源
hch
2024-04-01 d01413b00ef631ac20347716b23818b0b811f65f
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
175
176
177
178
179
180
181
182
#include <mono/metadata/w32process.h>
#include <mono/metadata/w32process-internals.h>
 
#if defined(PLATFORM_UNITY) && defined(UNITY_USE_PLATFORM_STUBS)
 
#ifdef HOST_WIN32
typedef struct {
    gpointer lpBaseOfDll;
    guint32 SizeOfImage;
    gpointer EntryPoint;
} MODULEINFO;
#endif
 
void
mono_w32process_init (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
}
 
void
mono_w32process_cleanup (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
}
 
gpointer
ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return NULL;
}
 
MonoBoolean
ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoW32ProcessStartInfo *proc_start_info, MonoW32ProcessInfo *process_info)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoW32ProcessStartInfo *proc_start_info, gpointer stdin_handle,
                                 gpointer stdout_handle, gpointer stderr_handle, MonoW32ProcessInfo *process_info)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoArray *
ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return NULL;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
gint32
ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
MonoBoolean
ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creationtime, gint64 *exittime, gint64 *kerneltime, gint64 *usertime)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
gpointer
ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
gboolean
mono_w32process_get_fileversion_info (gunichar2 *filename, gpointer* data)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
guint32
mono_w32process_get_fileversion_info_size (gunichar2 *filename, guint32 *handle)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
guint32
mono_w32process_get_pid (gpointer handle)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
guint32
mono_w32process_module_get_filename (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gboolean
mono_w32process_module_get_information (gpointer process, gpointer module, MODULEINFO *modinfo, guint32 size)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
guint32
mono_w32process_module_get_name (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
 
gboolean
mono_w32process_try_get_modules (gpointer process, gpointer *modules, guint32 size, guint32 *needed)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
guint32
mono_w32process_ver_language_name (guint32 lang, gunichar2 *lang_out, guint32 lang_len)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return 0;
}
 
gboolean
mono_w32process_ver_query_value (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
{
    g_assert(0 && "This function is not yet implemented for the Unity platform.");
    return FALSE;
}
 
#endif /* PLATFORM_UNITY && UNITY_USE_PLATFORM_STUBS */