Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/angle
 Path: blob/main_old/src/libGLESv2/egl_stubs_autogen.h
1693 views
1
// GENERATED FILE - DO NOT EDIT.

2
// Generated by generate_entry_points.py using data from egl.xml.

3
//

4
// Copyright 2020 The ANGLE Project Authors. All rights reserved.

5
// Use of this source code is governed by a BSD-style license that can be

6
// found in the LICENSE file.

7
//

8
// egl_stubs_autogen.h: Stubs for EGL entry points.

9


10
#ifndef LIBGLESV2_EGL_STUBS_AUTOGEN_H_

11
#define LIBGLESV2_EGL_STUBS_AUTOGEN_H_

12


13
#include <EGL/egl.h>

14
#include <EGL/eglext.h>

15


16
#include "common/PackedEGLEnums_autogen.h"

17


18
namespace gl

19
{

20
class Context;

21
}  // namespace gl

22


23
namespace egl

24
{

25
class AttributeMap;

26
class Device;

27
class Display;

28
class Image;

29
class Stream;

30
class Surface;

31
class Sync;

32
class Thread;

33
struct Config;

34


35
EGLBoolean BindAPI(Thread *thread, EGLenum api);

36
EGLBoolean BindTexImage(Thread *thread,

37
                        egl::Display *dpyPacked,

38
                        Surface *surfacePacked,

39
                        EGLint buffer);

40
EGLBoolean ChooseConfig(Thread *thread,

41
                        egl::Display *dpyPacked,

42
                        const AttributeMap &attrib_listPacked,

43
                        EGLConfig *configs,

44
                        EGLint config_size,

45
                        EGLint *num_config);

46
EGLint ClientWaitSync(Thread *thread,

47
                      egl::Display *dpyPacked,

48
                      Sync *syncPacked,

49
                      EGLint flags,

50
                      EGLTime timeout);

51
EGLBoolean CopyBuffers(Thread *thread,

52
                       egl::Display *dpyPacked,

53
                       Surface *surfacePacked,

54
                       EGLNativePixmapType target);

55
EGLContext CreateContext(Thread *thread,

56
                         egl::Display *dpyPacked,

57
                         Config *configPacked,

58
                         gl::Context *share_contextPacked,

59
                         const AttributeMap &attrib_listPacked);

60
EGLImage CreateImage(Thread *thread,

61
                     egl::Display *dpyPacked,

62
                     gl::Context *ctxPacked,

63
                     EGLenum target,

64
                     EGLClientBuffer buffer,

65
                     const AttributeMap &attrib_listPacked);

66
EGLSurface CreatePbufferFromClientBuffer(Thread *thread,

67
                                         egl::Display *dpyPacked,

68
                                         EGLenum buftype,

69
                                         EGLClientBuffer buffer,

70
                                         Config *configPacked,

71
                                         const AttributeMap &attrib_listPacked);

72
EGLSurface CreatePbufferSurface(Thread *thread,

73
                                egl::Display *dpyPacked,

74
                                Config *configPacked,

75
                                const AttributeMap &attrib_listPacked);

76
EGLSurface CreatePixmapSurface(Thread *thread,

77
                               egl::Display *dpyPacked,

78
                               Config *configPacked,

79
                               EGLNativePixmapType pixmap,

80
                               const AttributeMap &attrib_listPacked);

81
EGLSurface CreatePlatformPixmapSurface(Thread *thread,

82
                                       egl::Display *dpyPacked,

83
                                       Config *configPacked,

84
                                       void *native_pixmap,

85
                                       const AttributeMap &attrib_listPacked);

86
EGLSurface CreatePlatformWindowSurface(Thread *thread,

87
                                       egl::Display *dpyPacked,

88
                                       Config *configPacked,

89
                                       void *native_window,

90
                                       const AttributeMap &attrib_listPacked);

91
EGLSync CreateSync(Thread *thread,

92
                   egl::Display *dpyPacked,

93
                   EGLenum type,

94
                   const AttributeMap &attrib_listPacked);

95
EGLSurface CreateWindowSurface(Thread *thread,

96
                               egl::Display *dpyPacked,

97
                               Config *configPacked,

98
                               EGLNativeWindowType win,

99
                               const AttributeMap &attrib_listPacked);

100
EGLBoolean DestroyContext(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked);

101
EGLBoolean DestroyImage(Thread *thread, egl::Display *dpyPacked, Image *imagePacked);

102
EGLBoolean DestroySurface(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked);

103
EGLBoolean DestroySync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked);

104
EGLBoolean GetConfigAttrib(Thread *thread,

105
                           egl::Display *dpyPacked,

106
                           Config *configPacked,

107
                           EGLint attribute,

108
                           EGLint *value);

109
EGLBoolean GetConfigs(Thread *thread,

110
                      egl::Display *dpyPacked,

111
                      EGLConfig *configs,

112
                      EGLint config_size,

113
                      EGLint *num_config);

114
EGLContext GetCurrentContext(Thread *thread);

115
EGLDisplay GetCurrentDisplay(Thread *thread);

116
EGLSurface GetCurrentSurface(Thread *thread, EGLint readdraw);

117
EGLDisplay GetDisplay(Thread *thread, EGLNativeDisplayType display_id);

118
EGLint GetError(Thread *thread);

119
EGLDisplay GetPlatformDisplay(Thread *thread,

120
                              EGLenum platform,

121
                              void *native_display,

122
                              const AttributeMap &attrib_listPacked);

123
__eglMustCastToProperFunctionPointerType GetProcAddress(Thread *thread, const char *procname);

124
EGLBoolean GetSyncAttrib(Thread *thread,

125
                         egl::Display *dpyPacked,

126
                         Sync *syncPacked,

127
                         EGLint attribute,

128
                         EGLAttrib *value);

129
EGLBoolean Initialize(Thread *thread, egl::Display *dpyPacked, EGLint *major, EGLint *minor);

130
EGLBoolean MakeCurrent(Thread *thread,

131
                       egl::Display *dpyPacked,

132
                       Surface *drawPacked,

133
                       Surface *readPacked,

134
                       gl::Context *ctxPacked);

135
EGLenum QueryAPI(Thread *thread);

136
EGLBoolean QueryContext(Thread *thread,

137
                        egl::Display *dpyPacked,

138
                        gl::Context *ctxPacked,

139
                        EGLint attribute,

140
                        EGLint *value);

141
const char *QueryString(Thread *thread, egl::Display *dpyPacked, EGLint name);

142
EGLBoolean QuerySurface(Thread *thread,

143
                        egl::Display *dpyPacked,

144
                        Surface *surfacePacked,

145
                        EGLint attribute,

146
                        EGLint *value);

147
EGLBoolean ReleaseTexImage(Thread *thread,

148
                           egl::Display *dpyPacked,

149
                           Surface *surfacePacked,

150
                           EGLint buffer);

151
EGLBoolean ReleaseThread(Thread *thread);

152
EGLBoolean SurfaceAttrib(Thread *thread,

153
                         egl::Display *dpyPacked,

154
                         Surface *surfacePacked,

155
                         EGLint attribute,

156
                         EGLint value);

157
EGLBoolean SwapBuffers(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked);

158
EGLBoolean SwapInterval(Thread *thread, egl::Display *dpyPacked, EGLint interval);

159
EGLBoolean Terminate(Thread *thread, egl::Display *dpyPacked);

160
EGLBoolean WaitClient(Thread *thread);

161
EGLBoolean WaitGL(Thread *thread);

162
EGLBoolean WaitNative(Thread *thread, EGLint engine);

163
EGLBoolean WaitSync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLint flags);

164
}  // namespace egl

165
#endif  // LIBGLESV2_EGL_STUBS_AUTOGEN_H_

166


167