void initColorOne(int w, int h) {
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, color_one_vertex_shader_one);
GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, color_one_fragment_shader_one);
gProgram = glCreateProgram();
LOGI("Program %d\n", gProgram);
width = w;
height = h;
glAttachShader(gProgram, vertexShader);
checkGlError("glAttachShader");
glAttachShader(gProgram, fragmentShader);
checkGlError("glAttachShader");
glBindAttribLocation(gProgram, 0, "vPosition");
glBindAttribLocation(gProgram, 1, "vColor");
glLinkProgram(gProgram);
GLint linkStatus = GL_FALSE;
glGetProgramiv(gProgram, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
GLint bufLength = 0;
glGetProgramiv(gProgram, GL_INFO_LOG_LENGTH, &bufLength);
if (bufLength) {
char* buf = (char*) malloc(bufLength);
if (buf) {
glGetProgramInfoLog(gProgram, bufLength, NULL, buf);
LOGE("Could not link program:\n%s\n", buf);
free(buf);
}
}
}
LOGI("w %d, h %d\n",w, h);
glViewport(0, 0, w, h);
checkGlError("glViewport");
gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
gvColorHandle = glGetAttribLocation(gProgram, "vColor");
GLsizei maxCount = 10;
GLsizei count;
GLuint shaders[maxCount];
glGetAttachedShaders(gProgram, maxCount,
&count,
shaders);
LOGI("Attached Shader First element : %d\n", *shaders);
LOGI("ShaderCount %d\n", count);
GLint error = glGetError();
return;
}
Data attachShaderFour(){
GLuint program = glCreateProgram();
GLsizei maxCount = 10;
GLsizei count;
GLuint shaders[maxCount];
glGetAttachedShaders(program, maxCount,
&count,
shaders);
LOGI("Attached Shader First element : %d\n", *shaders);
LOGI("ShaderCount %d\n", count);
GLint error = glGetError();
Data data = {error, count, -1};
glDeleteProgram(program);
return data;
}
/* ‘ункци¤ удалени¤ шейдерной программы.
* ј–√”ћ≈Ќ“џ:
* - идентификатор загруженной программы:
* UINT ProgId;
* ¬ќ«¬–јўј≈ћќ≈ «Ќј„≈Ќ»≈: Ќет.
*/
VOID OK2_ShadProgClose( UINT ProgId )
{
UINT i, n, shdrs[4];
if (ProgId == 0)
return;
/* получаем присоединенные шейдера */
glGetAttachedShaders(ProgId, 4, &n, shdrs);
/* удал¤ем */
for (i = 0; i < n; i++)
{
glDetachShader(ProgId, shdrs[i]);
glDeleteShader(shdrs[i]);
}
glDeleteProgram(ProgId);
} /* End of 'OK2_ShadProgClose' function */
/* Shader program load function.
* ARGUMENTS:
* - shader program Id:
* UINT Prg;
* RETURNS: None.
*/
VOID MP2_RndShaderFree( UINT Prg )
{
UINT i, n, shds[5];
if (Prg == 0)
return;
/* Obtain program shaders count */
glGetAttachedShaders(Prg, 5, &n, shds);
for (i = 0; i < n; i++)
{
glDetachShader(Prg, shds[i]);
glDeleteShader(shds[i]);
}
glDeleteProgram(Prg);
} /* End of 'MP2_RndShaderFree' function */
Shader::~Shader()
{
if (id_ == 0)
return;
GLint numShaders = 0;
glGetProgramiv(id_, GL_ATTACHED_SHADERS, &numShaders);
GLuint *shaderNames = new GLuint[numShaders];
glGetAttachedShaders(id_, numShaders, NULL, shaderNames);
for (int i = 0; i < numShaders; ++i)
glDeleteShader(shaderNames[i]);
glDeleteProgram(id_);
delete[] shaderNames;
}
bool cShaderObject::IsShaderAttached( GLuint shader_id )
{
const GLsizei max_shaders = 4;
GLsizei actual_shaders = 0;
GLuint shaders[max_shaders];
for (int i = 0 ; i < max_shaders; ++i)
{
shaders[i] = 0;
}
glGetAttachedShaders(mShaderProgram, max_shaders, &actual_shaders, shaders);
for (int i = 0; i < actual_shaders; ++i)
{
if(shader_id == shaders[i])
{
return true;
}
}
return false;
}
void Shader::notifiyModification(const std::string& fname){
std::cout << "file " << fname << " modified! " << std::endl;
// what kind of shader is it? ignore, recompose both paths and compile again
std::string verFile = fname;
std::string fraFile = fname;
//"vs.glsl" has 7 chars
verFile.replace (verFile.end()-7, verFile.end(), std::string("vs.glsl"));
fraFile.replace (fraFile.end()-7, fraFile.end(), std::string("fs.glsl"));
std::cout << verFile << std::endl;
std::cout << fraFile << std::endl;
// load, compile...
fs::path verPath = verFile;
assert (fs::exists(verPath) && "no fragments shader");
const char* buff = loadShader(verPath);
unsigned vs = compileShader(buff, GL_VERTEX_SHADER);
delete[] buff;
fs::path fraPath = fraFile;
assert (fs::exists(fraPath) && "no fragments shader");
buff = loadShader(fraPath);
unsigned fs = compileShader(buff, GL_FRAGMENT_SHADER);
delete[] buff;
// create program
unsigned newid = linkProgram(vs, fs);
// we load and compile the others as well (could be cached)
if (is_valid(newid)){
// link, if everithing alright, change and delete previous.
unsigned sh[8];
int size;
glGetAttachedShaders (id, 8, &size, sh);
for (int i =0; i< size; ++i) glDeleteShader(sh[i]);
glDeleteProgram(id);
id = newid;
}
}
void RuntimeShaderEditor::getShaderSource(GLint program, char* buffer, GLint size)
{
GLint shadersCount = 0;
GLuint shaderNames[3];
GLuint toBeReplaced = 0;
char vs[SHADER_BUFFER_SIZE];
char fs[SHADER_BUFFER_SIZE];
vs[0] = 0x00;
fs[0] = 0x00;
glGetAttachedShaders(program, 3, &shadersCount, shaderNames);
for(int i = 0; i < shadersCount; i++)
{
int len = 0;
GLint typeAux = 0;
glGetShaderiv(shaderNames[i], GL_SHADER_TYPE, &typeAux);
glGetShaderSource(shaderNames[i], SHADER_BUFFER_SIZE, &len, typeAux == GL_VERTEX_SHADER ? vs : fs);
}
const char* format = "%s[SEPARATOR]%s";
sprintf(buffer, format, vs, fs);
}
Data attachShaderTen(){
GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, attach_shader_successful_complile_shader);
GLuint program = glCreateProgram();
glAttachShader(program, fragmentShader);
GLsizei maxCount = 10;
GLsizei count;
GLuint shaders[maxCount];
glGetAttachedShaders(program, maxCount,
&count,
shaders);
LOGI("Attached Shader First element : %d\n", *shaders);
LOGI("ShaderCount %d\n", count);
GLint error = glGetError();
Data data = {error, count, -1};
glDeleteShader(fragmentShader);
glDeleteProgram(program);
return data;
}
//! Destructor
COGLES2MaterialRenderer::~COGLES2MaterialRenderer()
{
if (CallBack)
CallBack->drop();
if (Program)
{
GLuint shaders[8];
GLint count;
glGetAttachedShaders(Program, 8, &count, shaders);
count=core::min_(count,8);
for (GLint i=0; i<count; ++i)
glDeleteShader(shaders[i]);
glDeleteProgram(Program);
Program = 0;
}
UniformInfo.clear();
}
static bool CopyShaderState_ContainsGeometryShader(GLuint oldProgID)
{
bool ret = false;
GLsizei numAttachedShaders = 0;
GLuint attachedShaderIDs[3] = {0};
GLint attachedShaderType = 0;
// glGetProgramiv(oldProgID, GL_ATTACHED_SHADERS, &numAttachedShaders);
glGetAttachedShaders(oldProgID, 3, &numAttachedShaders, &attachedShaderIDs[0]);
for (GLsizei n = 0; n < numAttachedShaders; n++) {
glGetShaderiv(attachedShaderIDs[n], GL_SHADER_TYPE, &attachedShaderType);
if ((ret |= (attachedShaderType == GL_GEOMETRY_SHADER))) {
break;
}
}
return ret;
}
Data attachShaderFive(){
GLuint fragmentShaderOne = glCreateShader(GL_FRAGMENT_SHADER);
GLuint fragmentShaderTwo = glCreateShader(GL_FRAGMENT_SHADER);
GLuint program = glCreateProgram();
glAttachShader(program, fragmentShaderOne);
glAttachShader(program, fragmentShaderTwo);
GLsizei maxCount = 10;
GLsizei count;
GLuint shaders[maxCount];
glGetAttachedShaders(program, maxCount,
&count,
shaders);
LOGI("Attached Shader First element : %d\n", *shaders);
LOGI("ShaderCount %d\n", count);
GLint error = glGetError();
Data data = {error, count, -1};
glDeleteProgram(program);
return data;
}
void ShaderManager::clearProgram(unsigned int programID)
{
if(programID==0)
{
return;
}
int countAttachedShaders = 0;
int maxCount = 10;
auto *attachedShaders = new unsigned int[maxCount];
glGetAttachedShaders(programID, maxCount, &countAttachedShaders, attachedShaders);
for(int i=0; i<countAttachedShaders; ++i)
{
glDetachShader(programID, attachedShaders[i]);
glDeleteShader(attachedShaders[i]);
}
delete [] attachedShaders;
glDeleteProgram(programID);
}
static inline void
dumpCurrentProgram(JSONWriter &json)
{
GLint program = 0;
glGetIntegerv(GL_CURRENT_PROGRAM, &program);
if (!program) {
return;
}
GLint attached_shaders = 0;
glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
if (!attached_shaders) {
return;
}
GLuint *shaders = new GLuint[attached_shaders];
GLsizei count = 0;
glGetAttachedShaders(program, attached_shaders, &count, shaders);
for (GLsizei i = 0; i < count; ++ i) {
dumpShader(json, shaders[i]);
}
delete [] shaders;
}
Handle<Value> GLESglGetAttachedShadersCallback(const Arguments& args) {
if (args.Length() != 1)
return v8::Undefined();
unsigned program = args[0]->Uint32Value();
int maxcount = 500;
int count = 0;
unsigned* shaders = new unsigned[maxcount];
glGetAttachedShaders((GLuint)program,
(GLsizei)maxcount,
(GLsizei*)&count,
(GLuint*)shaders);
Local<Array> res = Array::New(count);
for (int i = 0; i < count; ++i) {
res->Set(Integer::New(i), Uint32::New(shaders[i]));
}
delete[] shaders;
return res;
}
static inline void
dumpProgram(StateWriter &writer, Context &context, GLint program)
{
if (program <= 0) {
return;
}
GLint attached_shaders = 0;
glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
if (!attached_shaders) {
return;
}
ShaderMap shaderMap;
GLuint *shaders = new GLuint[attached_shaders];
GLsizei count = 0;
glGetAttachedShaders(program, attached_shaders, &count, shaders);
std::sort(shaders, shaders + count);
for (GLsizei i = 0; i < count; ++ i) {
getShaderSource(shaderMap, shaders[i]);
}
delete [] shaders;
for (ShaderMap::const_iterator it = shaderMap.begin(); it != shaderMap.end(); ++it) {
writer.beginMember(it->first);
writer.writeString(it->second);
writer.endMember();
}
// Dump NVIDIA GPU programs via GL_ARB_get_program_binary
if (context.ARB_get_program_binary) {
GLint binaryLength = 0;
glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
if (binaryLength > 0) {
std::vector<char> binary(binaryLength);
GLenum format = GL_NONE;
glGetProgramBinary(program, binaryLength, NULL, &format, &binary[0]);
if (format == 0x8e21) {
if (0) {
FILE *fp = fopen("program.bin", "wb");
if (fp) {
fwrite(&binary[0], 1, binaryLength, fp);
fclose(fp);
}
}
// Extract NVIDIA GPU programs
std::string str(binary.begin(), binary.end());
size_t end = 0;
while (true) {
// Each program starts with a !!NV header token
size_t start = str.find("!!NV", end);
if (start == std::string::npos) {
break;
}
// And is preceeded by a length DWORD
assert(start >= end + 4);
if (start < end + 4) {
break;
}
uint32_t length;
str.copy(reinterpret_cast<char *>(&length), 4, start - 4);
assert(start + length <= binaryLength);
if (start + length > binaryLength) {
break;
}
std::string nvProg = str.substr(start, length);
size_t eol = nvProg.find('\n');
std::string nvHeader = nvProg.substr(2, eol - 2);
writer.beginMember(nvHeader);
writer.writeString(nvProg);
writer.endMember();
end = start + length;
}
}
}
}
}
void get_attached_shaders(gl::uint_t program, gl::sizei_t maxCount, gl::sizei_t * count, gl::uint_t * shaders) {
glGetAttachedShaders(program, maxCount, count, shaders);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL20_nglGetAttachedShaders(JNIEnv *env, jclass clazz, jint program, jint maxCount, jlong count, jlong shaders, jlong function_pointer) {
GLsizei *count_address = (GLsizei *)(intptr_t)count;
GLuint *shaders_address = (GLuint *)(intptr_t)shaders;
glGetAttachedShadersPROC glGetAttachedShaders = (glGetAttachedShadersPROC)((intptr_t)function_pointer);
glGetAttachedShaders(program, maxCount, count_address, shaders_address);
}
bool OpenUtility::CShaderProgram::LinkProgram()
{
GLint status;
GLint nb;
GLsizei count;
unsigned int i;
int j;
CShaderFile *shader;
bool found,error;
CShaderFile::EShaderState state;
GLuint *idShaders;
glGetProgramiv(idProgram,GL_ATTACHED_SHADERS,&nb);
idShaders=new GLuint[nb];
glGetAttachedShaders(idProgram,nb,&count,idShaders);
CurLog="";
error=false;
for (i=0;i<ShaderList.GetSize() && !error;i++)
{
shader=ShaderList[i];
switch (state=shader->GetState())
{
case CShaderFile::EShaderNotValid:
State=EProgramNotValid;
CurLog.AddFormatStream("Shader %s(%d) is not valid\n",shader->GetName(),shader->GetId());
error=true;
break;
case CShaderFile::EShaderSourceModified:
if (!shader->CompileShader())
{
State=EProgramNotValid;
CurLog.AddFormatStream("Shader %s(%d) is not valid\n",shader->GetName(),shader->GetId());
error=true;
}
break;
default:
break;
}
for (j=0,found=false;j<count && !found;j++)
{
if (idShaders[j]==shader->GetId())
{
idShaders[j]=0;
found=true;
}
}
if (found)
{
if (state==CShaderFile::EShaderNoSource)
glDetachShader(idProgram,shader->GetId());
}
else
{
if (state==CShaderFile::EShaderValid)
glAttachShader(idProgram,shader->GetId());
}
}
for (j=0;j<count;j++)
{
if (idShaders[j]!=0)
glDetachShader(idProgram,idShaders[j]);
}
delete[] idShaders;
if (!error)
{
glLinkProgram(idProgram);
glValidateProgram(idProgram);
glGetProgramiv(idProgram,GL_LINK_STATUS,&status);
if (status==0)
{
GetOpenglLog();
State=EProgramNotValid;
}
else
{
State=EProgramValid;
VectVariable.DeleteAll();
MapVariable.RemoveAll();
// Parse attribute and uniform variables
GLsizei maxLength;
SShaderVariable *shaderVariable;
GLchar *varName;
glGetProgramiv(idProgram,GL_ACTIVE_ATTRIBUTES,&nb);
if (nb)
{
glGetProgramiv(idProgram,GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,&maxLength);
GLint varSize;
GLenum varType;
varName=new GLchar[maxLength];
for (j=0;j<nb;j++)
{
glGetActiveAttrib(idProgram,j,maxLength,NULL,&varSize,&varType,varName);
shaderVariable=VectVariable.Add(new SShaderVariable(varName,EVariableUniform,varType,varSize,glGetAttribLocation(idProgram,varName)));
MapVariable[shaderVariable->Name.GetStream()]=shaderVariable;
//GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4, GL_FLOAT_MAT2, GL_FLOAT_MAT3, GL_FLOAT_MAT4, GL_FLOAT_MAT2x3, GL_FLOAT_MAT2x4, GL_FLOAT_MAT3x2, GL_FLOAT_MAT3x4, GL_FLOAT_MAT4x2, or GL_FLOAT_MAT4x3
}
delete[] varName;
}
glGetProgramiv(idProgram,GL_ACTIVE_UNIFORMS,&nb);
if (nb)
{
glGetProgramiv(idProgram,GL_ACTIVE_UNIFORM_MAX_LENGTH,&maxLength);
GLint varSize;
GLenum varType;
varName=new GLchar[maxLength];
for (j=0;j<nb;j++)
{
glGetActiveUniform(idProgram,j,maxLength,NULL,&varSize,&varType,varName);
shaderVariable=VectVariable.Add(new SShaderVariable(varName,EVariableUniform,varType,varSize,glGetUniformLocation(idProgram,varName)));
MapVariable[shaderVariable->Name.GetStream()]=shaderVariable;
}
delete[] varName;
}
}
}
return(State==EProgramValid);
}
void Shader::build()
{
if (Code.size() == reqArr.size())
{
for (size_t i = 0; i < Code.size(); i++)
{
Code[i] = *((ShaderCode*)reqArr[i].get());
Code[i].makeShader();
vector<Uniform>& t = Code[i].getUniforms();
for (Uniform& temp : t)
Uniforms.insert(Uniforms.begin() + findUniform(temp.getName(), 0, Uniforms.size()), temp);
}
}
if (!program.get() || !glIsProgram(*program))
*program = glCreateProgram(); //no Program existent creating
int attached = 0;
glGetProgramiv(*program, GL_ATTACHED_SHADERS, &attached);
if (attached) //in case old Shaders are attached
{
vector<GLuint> shaders = vector<GLuint>();
for (char i = 0; i < 16; i++) //write invaid numbers to seperate them
shaders.push_back(-1);
glGetAttachedShaders(*program, 16, NULL, &shaders[0]); //get all Shaders attached to Program
for (GLuint shader : shaders)
if (shader != -1) //check if it is a valid shader
glDetachShader(*program, shader); //detaches Shader, DOES NO DELETE
attached = 0; //resets counter
}
for (ShaderCode& shader : Code)
{
//should check Shader values
glAttachShader(*program, shader.getPos());
int ShaderCount = 0;
glGetProgramiv( *program, GL_ATTACHED_SHADERS, &ShaderCount); //might turn out t be slow since it querries operations and wait for them
if (ShaderCount > attached) //used for Error catching
attached++;
}
if (attached > 0)
glLinkProgram(*program);
else
LOG << "OpenGL Program " << "NO SHADERS ATTACHED." << "\n";
int isLinked = 0;
glGetProgramiv(*program, GL_LINK_STATUS, &isLinked);
if (!isLinked)
{
GLint maxLength = 0;
glGetProgramiv(*program, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 1)
{
//The maxLength includes the NULL character
vector<GLchar> infoLog = vector<GLchar>(maxLength);
glGetProgramInfoLog(*program, maxLength, NULL, &infoLog[0]);
LOG << "OpenGL Program " << infoLog.data() << "\n";
}
}
//Uniform Phase
setUniforms();
}
uintptr_t processFn(struct fnargs* args, char* parg) {
uintptr_t ret = 0;
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg, (GLenum)args->a2);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)parg);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)parg);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)parg);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)&ret, (GLuint*)parg);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)parg);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)parg);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)parg);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg, &((GLint*)parg)[2]);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)parg);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)parg);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)parg);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)parg);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)parg);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
return ret;
}
static void
shader_init(void)
{
GLuint v, f, program;
const char *p;
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
program = glCreateProgram();
/* Compile the vertex shader */
p = vertex_shader;
v = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(v, 1, &p, NULL);
glCompileShader(v);
GLint log_length, char_count;
char *log;
GLint status;
glGetShaderiv(v, GL_COMPILE_STATUS, &status);
if (status) {
glAttachShader(program, v);
glDeleteShader(v); // mark for deletion on detach
}
else {
glGetShaderiv(v, GL_INFO_LOG_LENGTH, &log_length);
log = malloc(log_length);
glGetShaderInfoLog(v, log_length, &char_count, log);
fprintf(stderr,"%s: vertex shader compilation failure:\n%s\n", __FUNCTION__, log);
free(log);
}
/* Compile the fragment shader */
p = fragment_shader;
f = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(f, 1, &p, NULL);
glCompileShader(f);
glGetShaderiv(f, GL_COMPILE_STATUS, &status);
if (status) {
glAttachShader(program, f);
glDeleteShader(f); // mark for deletion on detach
}
else {
glGetShaderiv(f, GL_INFO_LOG_LENGTH, &log_length);
log = malloc(log_length);
glGetShaderInfoLog(f, log_length, &char_count, log);
fprintf(stderr,"%s: fragment shader compilation failure:\n%s\n", __FUNCTION__, log);
free(log);
}
/* Create and link the shader program */
glBindAttribLocation(program, 0, "position");
glLinkProgram(program);
glValidateProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &status);
if (status) {
// Don't need the shader objects anymore.
GLuint shaders[2];
GLsizei shader_count;
glGetAttachedShaders(program, 2, &shader_count, shaders);
glDetachShader(program, shaders[0]);
glDetachShader(program, shaders[1]);
}
else {
// Report errors. Shader objects detached when program is deleted.
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
log = malloc(log_length);
glGetProgramInfoLog(program, log_length, &char_count, log);
fprintf(stderr,"%s: shader program link failure:\n%s\n", __FUNCTION__, log);
free(log);
}
int l1 = glGetAttribLocation(program, "position");
printf("location: %d\n",l1);
/* Enable the shaders */
glUseProgram(program);
}
