110 public native void glGetUniformuiv(int program, int location, IntBuffer params);

111

112 public native int glGetFragDataLocation(int program, String name);

113

114 public native void glUniform1uiv(int location, int count, IntBuffer value);

50 @Override public void glVertexAttribI4ui(int index, int x, int y, int z, int w){ SDLGL.glVertexAttribI4ui(index, x, y, z, w); }

51 @Override public void glGetUniformuiv(int program, int location, IntBuffer params){ SDLGL.glGetUniformuiv(program, location, params); }

52 @Override public int glGetFragDataLocation(int program, String name){ return SDLGL.glGetFragDataLocation(program, name); }

53 @Override public void glUniform1uiv(int location, int count, IntBuffer value){ SDLGL.glUniform1uiv(location, count, value); }

54 @Override public void glUniform3uiv(int location, int count, IntBuffer value){ SDLGL.glUniform3uiv(location, count, value); }

82 }

83

84 GLint GLStubApiBase::glGetFragDataLocationFn(GLuint program, const char* name) {

85 return 0;

86 }

322 #define glGetUniformuiv __aglGetUniformuiv

323 #define glBindFragDataLocation __aglBindFragDataLocation

324 #define glGetFragDataLocation __aglGetFragDataLocation

325 #define glUniform1ui __aglUniform1ui

326 #define glUniform2ui __aglUniform2ui

128 gl->getFloatv = (glGetFloatvFunc) loader->get("glGetFloatv");

129 gl->getFragDataIndex = (glGetFragDataIndexFunc) loader->get("glGetFragDataIndex");

130 gl->getFragDataLocation = (glGetFragDataLocationFunc) loader->get("glGetFragDataLocation");

131 gl->getFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameterivFunc) loader->get("glGetFramebufferAttachmentParameteriv");

132 gl->getInteger64i_v = (glGetInteger64i_vFunc) loader->get("glGetInteger64i_v");

123 gl->getError = (glGetErrorFunc) loader->get("glGetError");

124 gl->getFloatv = (glGetFloatvFunc) loader->get("glGetFloatv");

125 gl->getFragDataLocation = (glGetFragDataLocationFunc) loader->get("glGetFragDataLocation");

126 gl->getFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameterivFunc) loader->get("glGetFramebufferAttachmentParameteriv");

127 gl->getInteger64i_v = (glGetInteger64i_vFunc) loader->get("glGetInteger64i_v");

108 gl->getError = (glGetErrorFunc) loader->get("glGetError");

109 gl->getFloatv = (glGetFloatvFunc) loader->get("glGetFloatv");

110 gl->getFragDataLocation = (glGetFragDataLocationFunc) loader->get("glGetFragDataLocation");

111 gl->getFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameterivFunc) loader->get("glGetFramebufferAttachmentParameteriv");

112 gl->getIntegeri_v = (glGetIntegeri_vFunc) loader->get("glGetIntegeri_v");

119 gl->getError = (glGetErrorFunc) loader->get("glGetError");

120 gl->getFloatv = (glGetFloatvFunc) loader->get("glGetFloatv");

121 gl->getFragDataLocation = (glGetFragDataLocationFunc) loader->get("glGetFragDataLocation");

122 gl->getFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameterivFunc) loader->get("glGetFramebufferAttachmentParameteriv");

123 gl->getFramebufferParameteriv = (glGetFramebufferParameterivFunc) loader->get("glGetFramebufferParameteriv");

217 #define glGetFloatv glwGetFloatv

218 #define glGetFragDataIndex glwGetFragDataIndex

219 #define glGetFragDataLocation glwGetFragDataLocation

220 #define glGetFramebufferAttachmentParameteriv glwGetFramebufferAttachmentParameteriv

221 #define glGetFramebufferParameteriv glwGetFramebufferParameteriv

393 /*

394 * Class: com_badlogic_gdx_backends_iosrobovm_IOSGLES30

395 * Method: glGetFragDataLocation

396 * Signature: (ILjava/lang/String;)I

397 */

398 JNIEXPORT jint JNICALL Java_com_badlogic_gdx_backends_iosrobovm_IOSGLES30_glGetFragDataLocation

399 (JNIEnv *, jobject, jint, jstring);

400

408

409 @Override

410 public int glGetFragDataLocation (int program, String name) {

411 return GLES30.glGetFragDataLocation(program, name);

52 WEBGL_APICALL void GL_APIENTRY emscripten_glVertexAttribI4uiv (GLuint index, const GLuint *v);

53 WEBGL_APICALL void GL_APIENTRY emscripten_glGetUniformuiv (GLuint program, GLint location, GLuint *params);

54 WEBGL_APICALL GLint GL_APIENTRY emscripten_glGetFragDataLocation (GLuint program, const GLchar *name);

55 WEBGL_APICALL void GL_APIENTRY emscripten_glUniform1ui (GLint location, GLuint v0);

56 WEBGL_APICALL void GL_APIENTRY emscripten_glUniform2ui (GLint location, GLuint v0, GLuint v1);

323 #define glGetUniformuiv _al_glGetUniformuiv

324 #define glBindFragDataLocation _al_glBindFragDataLocation

325 #define glGetFragDataLocation _al_glGetFragDataLocation

326 #define glUniform1ui _al_glUniform1ui

327 #define glUniform2ui _al_glUniform2ui

126 # INPUT glGetFragDataLocation.name size not checked against 'name'

127 glGetFragDataLocation=wrapper.wrapper(glGetFragDataLocation).setInputArraySize(

128 'name', None

129 )

230

231 @Override

232 public int glGetFragDataLocation(int program, String name){

233 return GLES30.glGetFragDataLocation(program, name);

63 /// </param>

64 /// <returns>See summary.</returns>

65 [NativeApi(EntryPoint = "glGetFragDataLocationEXT")]

66 public abstract unsafe int GetFragDataLocation([Flow(FlowDirection.In)] uint program, [Count(Computed = "name"), Flow(FlowDirection.In)] char* name);

67

77 /// </param>

78 /// <returns>See summary.</returns>

79 [NativeApi(EntryPoint = "glGetFragDataLocationEXT")]

80 public abstract int GetFragDataLocation([Flow(FlowDirection.In)] uint program, [Count(Computed = "name"), Flow(FlowDirection.In)] ref char name);

81

331 /// </param>

332 /// <returns>See summary.</returns>

333 [NativeApi(EntryPoint = "glGetFragDataLocationEXT")]

334 public abstract int GetFragDataLocation([Flow(FlowDirection.In)] uint program, [Flow(FlowDirection.In)] string name);

335

158 getFragDataLocation :: Program -> String -> IO (Maybe DrawBufferIndex)

159 getFragDataLocation (Program program) varName = do

160 r <- withGLstring varName $ glGetFragDataLocation program

161 if r < 0

162 then return Nothing

227 private delegate int glGetFragDataLocationDelegate(uint program, sbyte* name);

228 [Require(MinVersion = "3.0")]

229 private static readonly glGetFragDataLocationDelegate glGetFragDataLocation = null;

230

231 public static int GetFragDataLocation(uint program, sbyte* name) { return glGetFragDataLocation(program, name); }

68 glDeleteShader(fsid);

69

70 GLint location = glGetFragDataLocation(program, "FragColor");

71 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());

72 EXPECT_EQ(-1, location);

73 location = glGetFragDataLocation(program, "Unknown");

74 EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());

75 EXPECT_EQ(-1, location);

77 glLinkProgram(program);

78

79 location = glGetFragDataLocation(program, "FragColor");

80 EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());

81 EXPECT_EQ(0, location);

146 Function<void, GLfloat*> Binding::GetFogFuncSGIS("glGetFogFuncSGIS");

147 Function<GLint, GLuint, const GLchar*> Binding::GetFragDataIndex("glGetFragDataIndex");

148 Function<GLint, GLuint, const GLchar*> Binding::GetFragDataLocation("glGetFragDataLocation");

149 Function<GLint, GLuint, const GLchar*> Binding::GetFragDataLocationEXT("glGetFragDataLocationEXT");

181 def glGetFragDataLocation(_program_, _name_)

182 (@@_glGetFragDataLocation ||= 1).tap { @@_glGetFragDataLocation += 1 }

183 end

184

271 gl->getFloatv = glGetFloatv;

272 gl->getFragDataIndex = glGetFragDataIndex;

273 gl->getFragDataLocation = glGetFragDataLocation;

274 gl->getFramebufferAttachmentParameteriv = glGetFramebufferAttachmentParameteriv;

275 gl->getFramebufferParameteriv = glGetFramebufferParameteriv;

181 }

182

183 public static int glGetFragDataLocation(int i, String str) {

184 return GLES30Adapter.glGetFragDataLocation(i, str);

62 alias void function (GLuint program, GLint location, GLuint *params) fp_glGetUniformuivEXT;

63 alias void function (GLuint program, GLuint color, GLchar *name) fp_glBindFragDataLocationEXT;

64 alias GLint function (GLuint program, GLchar *name) fp_glGetFragDataLocationEXT;

65 alias void function (GLint location, GLuint v0) fp_glUniform1uiEXT;

66 alias void function (GLint location, GLuint v0, GLuint v1) fp_glUniform2uiEXT;

109 return checkedCall(gl_, "BindFragDataLocation", funcPtr, params__);

110 }

111 GLint GetFragDataLocation(GL gl_, ParameterTypeTuple!(fp_glGetFragDataLocationEXT) params__) {

112 auto gl = _getGL(gl_);

113 version (DglExtSupportAsserts) assert (gl.extEnabled.length > extensionId__ && gl.extEnabled[extensionId__] > 0, extNotEnabledError);

114 auto funcPtr = cast(fp_glGetFragDataLocationEXT)(gl.extFuncs[extensionId__][2]);

115 return checkedCall(gl_, "GetFragDataLocation", funcPtr, params__);

116 }

256 extern PFNGLGETUNIFORMUIVPROC glGetUniformuiv;

257 extern PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation;

258 extern PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation;

259 extern PFNGLUNIFORM1UIPROC glUniform1ui;

260 extern PFNGLUNIFORM2UIPROC glUniform2ui;

393 /*

394 * Class: arc_backend_robovm_IOSGLES30

395 * Method: glGetFragDataLocation

396 * Signature: (ILjava/lang/String;)I

397 */

398 JNIEXPORT jint JNICALL Java_arc_backend_robovm_IOSGLES30_glGetFragDataLocation

399 (JNIEnv *, jobject, jint, jstring);

400

127

128 #if os(iOS) || os(Android)

129 glGetFragDataLocation(self.program, "glFragData0");

130 #else

131 glBindFragDataLocation(self.program, 0, "glFragData0");

526 #ifndef glGetFragDataLocation

527 #define glGetFragDataLocation _OPENGL_API_PREFIX_ glGetFragDataLocation

528 #endif

529

179 }

180

181 public static int glGetFragDataLocation(int i, String str) {

182 return GLES30.glGetFragDataLocation(i, str);

115 void glGetUniformuivEXT(GLuint program, GLint location, GLuint *params);

116 void glBindFragDataLocationEXT(GLuint program, GLuint colorNumber, const GLchar *name);

117 GLint glGetFragDataLocationEXT(GLuint program, const GLchar *name);

118 void glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);

119 void glEnableIndexedEXT(GLenum target, GLuint index);

96 glGetError

97 glGetFloatv

98 glGetFragDataLocation

99 glGetFramebufferAttachmentParameter*

100 glGetIntegerv

80

81 void glBindFragDataLocationEXT(GLuint program, GLuint colorNumber, const GLchar * name);

82 GLint glGetFragDataLocationEXT(GLuint program, const GLchar *name);

54 FIND_PROC(glVertexAttribI4uiv);

55 FIND_PROC(glGetUniformuiv);

56 FIND_PROC(glGetFragDataLocation);

57 FIND_PROC(glUniform1ui);

58 FIND_PROC(glUniform2ui);

172 !glVertexAttribI4uiv ||

173 !glGetUniformuiv ||

174 !glGetFragDataLocation ||

175 !glUniform1ui ||

176 !glUniform2ui ||

284 GL_APICALL void (* GL_APIENTRY glVertexAttribI4uiv) (GLuint index, const GLuint* v);

285 GL_APICALL void (* GL_APIENTRY glGetUniformuiv) (GLuint program, GLint location, GLuint* params);

286 GL_APICALL GLint (* GL_APIENTRY glGetFragDataLocation) (GLuint program, const GLchar *name);

287 GL_APICALL void (* GL_APIENTRY glUniform1ui) (GLint location, GLuint v0);

288 GL_APICALL void (* GL_APIENTRY glUniform2ui) (GLint location, GLuint v0, GLuint v1);

166 <li><a href="glGetError.xhtml" target="pagedisplay">glGetError</a></li>

167 <li><a href="glGet.xhtml" target="pagedisplay">glGetFloatv</a></li>

168 <li><a href="glGetFragDataLocation.xhtml" target="pagedisplay">glGetFragDataLocation</a></li>

169 <li><a href="glGetFramebufferAttachmentParameteriv.xhtml" target="pagedisplay">glGetFramebufferAttachmentParameteriv</a></li>

170 <li><a href="glGetFramebufferParameteriv.xhtml" target="pagedisplay">glGetFramebufferParameteriv</a></li>

152 <li><a href="glGetError.xhtml" target="pagedisplay">glGetError</a></li>

153 <li><a href="glGet.xhtml" target="pagedisplay">glGetFloatv</a></li>

154 <li><a href="glGetFragDataLocation.xhtml" target="pagedisplay">glGetFragDataLocation</a></li>

155 <li><a href="glGetFramebufferAttachmentParameteriv.xhtml" target="pagedisplay">glGetFramebufferAttachmentParameteriv</a></li>

156 <li><a href="glGet.xhtml" target="pagedisplay">glGetInteger64i_v</a></li>

54 )

55

56 glGetFragDataLocationEXT = platform.createExtensionFunction(

57 'glGetFragDataLocationEXT',dll=platform.GL,

59 resultType=constants.GLint,

60 argTypes=(constants.GLuint,arrays.GLcharArray,),

61 doc='glGetFragDataLocationEXT(GLuint(program), GLcharArray(name)) -> constants.GLint',

62 argNames=('program','name',),

63 deprecated=_DEPRECATED,

10 _GetUniformuivEXT = GetProcAdress< GetUniformuivEXTDelegate >( "glGetUniformuivEXT" );

11 _BindFragDataLocationEXT = GetProcAdress< BindFragDataLocationEXTDelegate >( "glBindFragDataLocationEXT" );

12 _GetFragDataLocationEXT = GetProcAdress< GetFragDataLocationEXTDelegate >( "glGetFragDataLocationEXT" );

13 _Uniform1uiEXT = GetProcAdress< Uniform1uiEXTDelegate >( "glUniform1uiEXT" );

14 _Uniform2uiEXT = GetProcAdress< Uniform2uiEXTDelegate >( "glUniform2uiEXT" );

51 if(!glBindExtFunc(cast(void**)&glBindFragDataLocationEXT, "glBindFragDataLocationEXT"))

52 return false;

53 if(!glBindExtFunc(cast(void**)&glGetFragDataLocationEXT, "glGetFragDataLocationEXT"))

54 return false;

55 if(!glBindExtFunc(cast(void**)&glGetUniformuivEXT, "glGetUniformuivEXT"))

172 {

173 void function(GLuint,GLuint,GLchar*) glBindFragDataLocationEXT;

174 GLint function(GLuint,GLchar*) glGetFragDataLocationEXT;

175 void function(GLuint,GLint,GLuint*) glGetUniformuivEXT;

176 void function(GLuint,GLenum,GLint*) glGetVertexAttribIivEXT;

19 extern PFNGLENDTRANSFORMFEEDBACKPROC glEndTransformFeedback;

20 extern PFNGLGETBOOLEANI_VPROC glGetBooleani_v;

21 extern PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation;

22 extern PFNGLGETSTRINGIPROC glGetStringi;

23 extern PFNGLGETTEXPARAMETERIIVPROC glGetTexParameterIiv;

223 const QString FragName = QString( "fug_Fragment%1" ).arg( i );

224

225 GLint FragData = GL32->glGetFragDataLocation( mProgram->programId(), FragName.toLatin1().constData() );

226

227 mFragmentOutputs[ i ] = ( FragData == -1 ? GL_NONE : GL_COLOR_ATTACHMENT0 + i );

197 NOpenGLProc::TGenerateMipmap glGenerateMipmap; NOpenGLProc::EProcType statusGenerateMipmap;

198 NOpenGLProc::TGetBooleani_v glGetBooleani_v; NOpenGLProc::EProcType statusGetBooleani_v;

199 NOpenGLProc::TGetFragDataLocation glGetFragDataLocation; NOpenGLProc::EProcType statusGetFragDataLocation;

200 NOpenGLProc::TGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameteriv; NOpenGLProc::EProcType statusGetFramebufferAttachmentParameteriv;

201 NOpenGLProc::TGetIntegeri_v glGetIntegeri_v; NOpenGLProc::EProcType statusGetIntegeri_v;

893 inline void generateMipmap(GLenum target) { glGenerateMipmap(target); }

894 inline void getBooleani_v(GLenum target, GLuint index, GLboolean *data) { glGetBooleani_v(target, index, data); }

895 inline GLint getFragDataLocation(GLuint program, const GLchar *name) { return glGetFragDataLocation(program, name); }

896 inline void getFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) { glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); }

897 inline void getIntegeri_v(GLenum target, GLuint index, GLint *data) { glGetIntegeri_v(target, index, data); }

191 glGenerateMipmap(NULL), statusGenerateMipmap(NOpenGLProc::TYPE_NOT_LOADED),

192 glGetBooleani_v(NULL), statusGetBooleani_v(NOpenGLProc::TYPE_NOT_LOADED),

193 glGetFragDataLocation(NULL), statusGetFragDataLocation(NOpenGLProc::TYPE_NOT_LOADED),

194 glGetFramebufferAttachmentParameteriv(NULL), statusGetFramebufferAttachmentParameteriv(NOpenGLProc::TYPE_NOT_LOADED),

195 glGetIntegeri_v(NULL), statusGetIntegeri_v(NOpenGLProc::TYPE_NOT_LOADED),

846 LOAD_GL_EXTENSION(glGenerateMipmap, statusGenerateMipmap, NOpenGLProc::TGenerateMipmap, "glGenerateMipmap", "glGenerateMipmapARB", "glGenerateMipmapEXT");

847 LOAD_GL_EXTENSION(glGetBooleani_v, statusGetBooleani_v, NOpenGLProc::TGetBooleani_v, "glGetBooleani_v", "glGetBooleani_vARB", "glGetBooleani_vEXT");

848 LOAD_GL_EXTENSION(glGetFragDataLocation, statusGetFragDataLocation, NOpenGLProc::TGetFragDataLocation, "glGetFragDataLocation", "glGetFragDataLocationARB", "glGetFragDataLocationEXT");

849 LOAD_GL_EXTENSION(glGetFramebufferAttachmentParameteriv, statusGetFramebufferAttachmentParameteriv, NOpenGLProc::TGetFramebufferAttachmentParameteriv, "glGetFramebufferAttachmentParameteriv", "glGetFramebufferAttachmentParameterivARB", "glGetFramebufferAttachmentParameterivEXT");

850 LOAD_GL_EXTENSION(glGetIntegeri_v, statusGetIntegeri_v, NOpenGLProc::TGetIntegeri_v, "glGetIntegeri_v", "glGetIntegeri_vARB", "glGetIntegeri_vEXT");

248 PFNGLDECLTYPE PFNGLGETUNIFORMUIVPROC glGetUniformuiv;

249 PFNGLDECLTYPE PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation;

250 PFNGLDECLTYPE PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation;

251 PFNGLDECLTYPE PFNGLUNIFORM1UIPROC glUniform1ui;

252 PFNGLDECLTYPE PFNGLUNIFORM2UIPROC glUniform2ui;

19 }

20

21 GLint VKGL_APIENTRY OpenGL::vkglGetFragDataLocation(GLuint program,

22 const GLchar* name)

23 {

24 const auto& dispatch_table_ptr = OpenGL::g_dispatch_table_ptr;

25

26 VKGL_TRACE("glGetFragDataLocation(program=[%u] name=[%s])",

27 program,

28 name);

29

30 return dispatch_table_ptr->pGLGetFragDataLocation(dispatch_table_ptr->bound_context_ptr,

31 program,

32 name);

101 public Buffer glGetBufferPointerv(int paramInt1, int paramInt2) { return GLES30.glGetBufferPointerv(paramInt1, paramInt2); }

102

103 public int glGetFragDataLocation(int paramInt, String paramString) { return GLES30.glGetFragDataLocation(paramInt, paramString); }

104

105 public void glGetInteger64v(int paramInt, LongBuffer paramLongBuffer) { GLES30.glGetInteger64v(paramInt, paramLongBuffer); }

125 Function<void, GLfloat *> Binding::GetFogFuncSGIS("glGetFogFuncSGIS");

126 Function<GLint, GLuint, const GLchar *> Binding::GetFragDataIndex("glGetFragDataIndex");

127 Function<GLint, GLuint, const GLchar *> Binding::GetFragDataLocation("glGetFragDataLocation");

128 Function<GLint, GLuint, const GLchar *> Binding::GetFragDataLocationEXT("glGetFragDataLocationEXT");

69 GetUniformLocation = find< GetUniformLocation_t >( "glGetUniformLocation" );

70 GetAttribLocation = find< GetAttribLocation_t >( "glGetAttribLocation" );

71 GetFragDataLocation = find< GetFragDataLocation_t >( "glGetFragDataLocationEXT" );

72

73 GenBuffers = find< GenBuffers_t >( "glGenBuffers" );

63

64 m_DownSamplerShader->Begin();

65 param.Attachment = glGetFragDataLocation(

66 m_DownSamplerShader->GetProgramObject(), "ColorBuffer");

67 Logger::Log() << " * Attachment : " << param.Attachment << "\n";

72

73 m_ManualMipmappingShader->Begin();

74 param.Attachment = glGetFragDataLocation(

75 m_ManualMipmappingShader->GetProgramObject(), "ColorBuffer");

76 Logger::Log() << " * Attachment : " << param.Attachment << "\n";

84 using theBaseClass_t::glVertexAttribI4uiv;

85 using theBaseClass_t::glGetUniformuiv;

86 using theBaseClass_t::glGetFragDataLocation;

87 using theBaseClass_t::glUniform1ui;

88 using theBaseClass_t::glUniform2ui;

51 typedef GL_APICALL void (GL_APIENTRY *glVertexAttribI4uivPROC) (GLuint index, const GLuint * v);

52 typedef GL_APICALL void (GL_APIENTRY *glGetUniformuivPROC) (GLuint program, GLint location, GLuint * params);

53 typedef GL_APICALL GLint (GL_APIENTRY *glGetFragDataLocationPROC) (GLuint program, const GLchar * name);

54 typedef GL_APICALL void (GL_APIENTRY *glUniform1uiPROC) (GLint location, GLuint v0);

55 typedef GL_APICALL void (GL_APIENTRY *glUniform2uiPROC) (GLint location, GLuint v0, GLuint v1);

156 static glVertexAttribI4uivPROC glVertexAttribI4uiv;

157 static glGetUniformuivPROC glGetUniformuiv;

158 static glGetFragDataLocationPROC glGetFragDataLocation;

159 static glUniform1uiPROC glUniform1ui;

160 static glUniform2uiPROC glUniform2ui;

821 {"nglVertexAttribI4uiv", "(IJ)V", (void *)&Java_org_lwjgl_opengles_GLES30_nglVertexAttribI4uiv, "glVertexAttribI4uiv", (void *)&glVertexAttribI4uiv, false},

822 {"nglGetUniformuiv", "(IIJ)V", (void *)&Java_org_lwjgl_opengles_GLES30_nglGetUniformuiv, "glGetUniformuiv", (void *)&glGetUniformuiv, false},

823 {"nglGetFragDataLocation", "(IJ)I", (void *)&Java_org_lwjgl_opengles_GLES30_nglGetFragDataLocation, "glGetFragDataLocation", (void *)&glGetFragDataLocation, false},

824 {"nglUniform1ui", "(II)V", (void *)&Java_org_lwjgl_opengles_GLES30_nglUniform1ui, "glUniform1ui", (void *)&glUniform1ui, false},

825 {"nglUniform2ui", "(III)V", (void *)&Java_org_lwjgl_opengles_GLES30_nglUniform2ui, "glUniform2ui", (void *)&glUniform2ui, false},

45 @_f

46 @_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray)

47 def glGetFragDataLocationEXT(program,name):pass

48 @_f

49 @_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuintArray)

230 - GLuint color

231 - string name

232 glGetFragDataLocation:

233 return_type: GLint

234 parameters:

204 defer freeString(cname)

205

206 return int(C.glGetFragDataLocation(C.GLuint(program), cname))

207 }

208

337 PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;

338 PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL;

339 PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;

340 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;

341 PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv = NULL;

9 [[gl.get_frag_data_location]]

10 * _location_ = *get_frag_data_location*(_program_, _name_) +

11 [small]#Rfr: https://www.khronos.org/opengl/wiki/GLAPI/glGetFragDataLocation[glGetFragDataLocation].#

12

13 [[gl.get_frag_data_index]]

96 */

97 printf("Querying location before linking...\n");

98 loc = glGetFragDataLocation(prog, "v");

99 if (!piglit_check_gl_error(GL_INVALID_OPERATION))

100 piglit_report_result(PIGLIT_FAIL);

114

115 printf("Querying location of nonexistent variable...\n");

116 loc = glGetFragDataLocation(prog, "waldo");

117 if (!piglit_check_gl_error(GL_NO_ERROR))

118 piglit_report_result(PIGLIT_FAIL);

141

142 printf("Querying locations after binding and linking...\n");

143 loc = glGetFragDataLocation(prog, "v");

144 if (!piglit_check_gl_error(GL_NO_ERROR))

145 piglit_report_result(PIGLIT_FAIL);

42 typedef void (APIENTRY *glGetUniformuivPROC) (GLuint program, GLint location, GLuint * params);

43 typedef void (APIENTRY *glBindFragDataLocationPROC) (GLuint program, GLuint colorNumber, const GLchar * name);

44 typedef GLint (APIENTRY *glGetFragDataLocationPROC) (GLuint program, const GLchar * name);

45 typedef void (APIENTRY *glBeginConditionalRenderPROC) (GLuint id, GLenum mode);

46 typedef void (APIENTRY *glEndConditionalRenderPROC) ();

312 JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL30_nglGetFragDataLocation(JNIEnv *env, jclass clazz, jint program, jlong name, jlong function_pointer) {

313 const GLchar *name_address = (const GLchar *)(intptr_t)name;

314 glGetFragDataLocationPROC glGetFragDataLocation = (glGetFragDataLocationPROC)((intptr_t)function_pointer);

315 GLint __result = glGetFragDataLocation(program, name_address);

42 typedef void (APIENTRY *glGetUniformuivPROC) (GLuint program, GLint location, GLuint * params);

43 typedef void (APIENTRY *glBindFragDataLocationPROC) (GLuint program, GLuint colorNumber, const GLchar * name);

44 typedef GLint (APIENTRY *glGetFragDataLocationPROC) (GLuint program, const GLchar * name);

45 typedef void (APIENTRY *glBeginConditionalRenderPROC) (GLuint id, GLenum mode);

46 typedef void (APIENTRY *glEndConditionalRenderPROC) ();

312 JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GL30_nglGetFragDataLocation(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {

313 const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;

314 glGetFragDataLocationPROC glGetFragDataLocation = (glGetFragDataLocationPROC)((intptr_t)function_pointer);

315 GLint __result = glGetFragDataLocation(program, name_address);

306 //####glGetFragDataLocationEXT

307 {"glGetFragDataLocationEXT", luaglew_glGetFragDataLocationEXT},

308 //####glUniform1uiEXT

309 {"glUniform1uiEXT", luaglew_glUniform1uiEXT},

942 //####glGetFragDataLocation

943 {"glGetFragDataLocation", luaglew_glGetFragDataLocation},

944 //####glUniform1ui

945 {"glUniform1ui", luaglew_glUniform1ui},

106 using theBaseClass_t::glGetUniformuiv;

107 using theBaseClass_t::glBindFragDataLocation;

108 using theBaseClass_t::glGetFragDataLocation;

109 using theBaseClass_t::glUniform1ui;

110 using theBaseClass_t::glUniform2ui;

377

378 @Override

379 public int glGetFragDataLocation(int program, String name) {

380 return GLES30.glGetFragDataLocation(program, name);

37 typedef void (APIENTRY *glGetUniformuivEXTPROC) (GLuint program, GLint location, GLuint * params);

38 typedef void (APIENTRY *glBindFragDataLocationEXTPROC) (GLuint program, GLuint colorNumber, const GLchar * name);

39 typedef GLint (APIENTRY *glGetFragDataLocationEXTPROC) (GLuint program, const GLchar * name);

40

41 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) {

233 JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) {

234 const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position;

235 glGetFragDataLocationEXTPROC glGetFragDataLocationEXT = (glGetFragDataLocationEXTPROC)((intptr_t)function_pointer);

236 GLint __result = glGetFragDataLocationEXT(program, name_address);

137 }

138

139 // todo: add getFragment: glGetFragDataLocation

140

141 /** Set the $(D uniform) value in this program. */

121 }

122

123 loc = glGetFragDataLocation(prog, "unicorn");

124 if (!piglit_check_gl_error(GL_NO_ERROR))

125 piglit_report_result(PIGLIT_FAIL);

150 }

151

152 loc = glGetFragDataLocation(prog, "unicorn");

153 if (!piglit_check_gl_error(GL_NO_ERROR))

154 piglit_report_result(PIGLIT_FAIL);

409 inline GLint ShaderProgram::get_frag_data_location(const GLchar* const name) const noexcept

410 {

411 return glGetFragDataLocation(gpu_id(), name);

412 }

413 } // end draw namespace

239 GL_PROC(void, glGetUniformuiv, GLuint, GLint, GLuint *)

240 GL_PROC(void, glBindFragDataLocation, GLuint, GLuint, const GLchar *)

241 GL_PROC(GLint, glGetFragDataLocation, GLuint, const GLchar *)

242 GL_PROC(void, glUniform1ui, GLint, GLuint)

243 GL_PROC(void, glUniform2ui, GLint, GLuint, GLuint)

37 typedef void (APIENTRY *glGetUniformuivEXTPROC) (GLuint program, GLint location, GLuint * params);

38 typedef void (APIENTRY *glBindFragDataLocationEXTPROC) (GLuint program, GLuint colorNumber, const GLchar * name);

39 typedef GLint (APIENTRY *glGetFragDataLocationEXTPROC) (GLuint program, const GLchar * name);

40

41 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) {

233 JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jlong name, jlong function_pointer) {

234 const GLchar *name_address = (const GLchar *)(intptr_t)name;

235 glGetFragDataLocationEXTPROC glGetFragDataLocationEXT = (glGetFragDataLocationEXTPROC)((intptr_t)function_pointer);

236 GLint __result = glGetFragDataLocationEXT(program, name_address);

18 glGetUniformuiv,

19 glBindFragDataLocation,

20 glGetFragDataLocation,

21 glUniform1ui,

22 glUniform2ui,

70 GL_PROC(void, glVertexAttribI4uiv, GLuint, const GLuint *)

71 GL_PROC(void, glGetUniformuiv, GLuint, GLint, GLuint *)

72 GL_PROC(GLint, glGetFragDataLocation, GLuint, const GLchar *)

73 GL_PROC(void, glUniform1ui, GLint, GLuint )

74 GL_PROC(void, glUniform2ui, GLint, GLuint , GLuint)

34 GLXX_EXPORT void glGetUniformuivEXT(GLuint program, GLint location, GLuint* params);

35 GLXX_EXPORT void glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar* name);

36 GLXX_EXPORT GLint glGetFragDataLocationEXT(GLuint program, const GLchar* name);

37 GLXX_EXPORT void glUniform1uiEXT(GLint location, GLuint v0);

38 GLXX_EXPORT void glUniform2uiEXT(GLint location, GLuint v0, GLuint v1);

47 -- * Functions

48 glBindFragDataLocationEXT,

49 glGetFragDataLocationEXT,

50 glGetUniformuivEXT,

51 glUniform1uiEXT,

45 GLint location;

46

47 location = glGetFragDataLocationGAN(program->getHandle(), name.c_str());

48 if (location != index) {

49 NodeException e(tag);

193 GL_EXT_PROC(PFNGLGETUNIFORMUIVPROC, glGetUniformuiv);

194 GL_EXT_PROC(PFNGLBINDFRAGDATALOCATIONPROC, glBindFragDataLocation);

195 GL_EXT_PROC(PFNGLGETFRAGDATALOCATIONPROC, glGetFragDataLocation);

196 GL_EXT_PROC(PFNGLUNIFORM1UIPROC, glUniform1ui);

197 GL_EXT_PROC(PFNGLUNIFORM2UIPROC, glUniform2ui);

56 VOID_SYNC_GL_FUNCTION_2(EM_FUNC_SIG_VII, void, glVertexAttribI4uiv, GLuint, const GLuint *);

57 VOID_SYNC_GL_FUNCTION_3(EM_FUNC_SIG_VIII, void, glGetUniformuiv, GLuint, GLint, GLuint *);

58 RET_SYNC_GL_FUNCTION_2(EM_FUNC_SIG_III, GLint, glGetFragDataLocation, GLuint, const GLchar *);

59 ASYNC_GL_FUNCTION_2(EM_FUNC_SIG_VII, void, glUniform1ui, GLint, GLuint);

60 ASYNC_GL_FUNCTION_3(EM_FUNC_SIG_VIII, void, glUniform2ui, GLint, GLuint, GLuint);

185 RETURN_FN(glVertexAttribI4uiv);

186 RETURN_FN(glGetUniformuiv);

187 RETURN_FN(glGetFragDataLocation);

188 RETURN_FN(glUniform1ui);

189 RETURN_FN(glUniform2ui);

22 typedef GLint (*PFNGLGETFRAGDATALOCATIONGANPROC)(GLuint,const char*);

23 extern PFNGLBINDFRAGDATALOCATIONGANPROC glBindFragDataLocationGAN;

24 extern PFNGLGETFRAGDATALOCATIONGANPROC glGetFragDataLocationGAN;

25

26 /** @brief Exception thrown while loading an extension. */

7 #include "Extensions.hpp"

8 PFNGLBINDFRAGDATALOCATIONGANPROC glBindFragDataLocationGAN=NULL;

9 PFNGLGETFRAGDATALOCATIONGANPROC glGetFragDataLocationGAN=NULL;

10

11

37 glBindFragDataLocationGAN = (PFNGLBINDFRAGDATALOCATIONPROC)

38 glutGetProcAddress("glBindFragDataLocation");

39 glGetFragDataLocationGAN = (PFNGLGETFRAGDATALOCATIONPROC)

40 glutGetProcAddress("glGetFragDataLocation");

49 glBindFragDataLocationGAN = (PFNGLBINDFRAGDATALOCATIONPROC)

50 Gdk::GL::get_proc_address("glBindFragDataLocation");

51 glGetFragDataLocationGAN = (PFNGLGETFRAGDATALOCATIONPROC)

52 Gdk::GL::get_proc_address("glGetFragDataLocation");

50 GL_APICALL void GL_APIENTRY emscripten_glVertexAttribI4uiv (GLuint index, const GLuint *v);

51 GL_APICALL void GL_APIENTRY emscripten_glGetUniformuiv (GLuint program, GLint location, GLuint *params);

52 GL_APICALL GLint GL_APIENTRY emscripten_glGetFragDataLocation (GLuint program, const GLchar *name);

53 GL_APICALL void GL_APIENTRY emscripten_glUniform1ui (GLint location, GLuint v0);

54 GL_APICALL void GL_APIENTRY emscripten_glUniform2ui (GLint location, GLuint v0, GLuint v1);

15 gl_UNSIGNED_INT_VEC3, gl_UNSIGNED_INT_VEC4,

16 gl_VERTEX_ATTRIB_ARRAY_INTEGER, glBindFragDataLocation,

17 glGetFragDataLocation, glGetUniformuiv, glUniform1ui,

18 glUniform1uiv, glUniform2ui, glUniform2uiv, glUniform3ui,

19 glUniform3uiv, glUniform4ui, glUniform4uiv)

126 "glBindFragDataLocationEXT"

127

128 foreign import CALLCONV unsafe "dynamic" dyn_glGetFragDataLocation

129 ::

130 Graphics.Rendering.OpenGL.Raw.Internal.Extensions.Invoker

131 (GLuint -> Ptr GLchar -> IO GLint)

132

133 glGetFragDataLocation :: GLuint -> Ptr GLchar -> IO GLint

134 glGetFragDataLocation

135 = dyn_glGetFragDataLocation ptr_glGetFragDataLocation

136

137 {-# NOINLINE ptr_glGetFragDataLocation #-}

119 public native void glGetUniformuiv (int program, int location, IntBuffer params);

120

121 public native int glGetFragDataLocation (int program, String name);

122

123 public native void glUniform1uiv (int location, int count, IntBuffer value);

10 namespace OpenGL

11 {

12 GLint VKGL_APIENTRY vkglGetFragDataLocation(GLuint program,

13 const GLchar* name);

14

15 GLint vkglGetFragDataLocation_with_validation(OpenGL::Context* in_context_ptr,

16 const GLuint& in_program,

17 const GLchar* in_name_ptr);

221 -------------------------------------*/

222 inline GLint shaderProgram::getFragDataLocation(const GLchar* const name) const {

223 return glGetFragDataLocation(programId, name);

224 }

225