asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/drivers/gles2/shader_gles2.cpp
Rémi Verschelde d8223ffa75 Welcome in 2017, dear changelog reader! 
That year should bring the long-awaited OpenGL ES 3.0 compatible renderer
with state-of-the-art rendering techniques tuned to work as low as middle
end handheld devices - without compromising with the possibilities given
for higher end desktop games of course. Great times ahead for the Godot
community and the gamers that will play our games!

(cherry picked from commit c7bc44d5ad)
2017-01-12 19:15:30 +01:00

772 lines
19 KiB
C++
Raw Blame History

/*************************************************************************/
/* shader_gles2.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "shader_gles2.h"
#ifdef GLES2_ENABLED
#include "print_string.h"
//#define DEBUG_OPENGL
#ifdef DEBUG_OPENGL
#define DEBUG_TEST_ERROR(m_section)\
{\
uint32_t err = glGetError();\
if (err) {\
print_line("OpenGL Error #"+itos(err)+" at: "+m_section);\
}\
}
#else
#define DEBUG_TEST_ERROR(m_section)
#endif
ShaderGLES2 *ShaderGLES2::active=NULL;
//#define DEBUG_SHADER
#ifdef DEBUG_SHADER
#define DEBUG_PRINT(m_text) print_line(m_text);
#else
#define DEBUG_PRINT(m_text)
#endif
void ShaderGLES2::bind_uniforms() {
if (!uniforms_dirty) {
return;
};
// upload default uniforms
const Map<uint32_t,Variant>::Element *E =uniform_defaults.front();
while(E) {
int idx=E->key();
int location=version->uniform_location[idx];
if (location<0) {
E=E->next();
continue;
}
const Variant &v=E->value();
_set_uniform_variant(location, v);
//print_line("uniform "+itos(location)+" value "+v+ " type "+Variant::get_type_name(v.get_type()));
E=E->next();
};
const Map<uint32_t,CameraMatrix>::Element* C = uniform_cameras.front();
while (C) {
int location = version->uniform_location[C->key()];
if (location<0) {
C=C->next();
continue;
}
glUniformMatrix4fv(location,1,false,&(C->get().matrix[0][0]));
C = C->next();
};
uniforms_dirty = false;
};
GLint ShaderGLES2::get_uniform_location(int p_idx) const {
ERR_FAIL_COND_V(!version, -1);
return version->uniform_location[p_idx];
};
bool ShaderGLES2::bind() {
if (active!=this || !version || new_conditional_version.key!=conditional_version.key) {
conditional_version=new_conditional_version;
version = get_current_version();
} else {
return false;
}
ERR_FAIL_COND_V(!version,false);
glUseProgram( version->id );
DEBUG_TEST_ERROR("Use Program");
active=this;
uniforms_dirty = true;
/*
* why on earth is this code here?
for (int i=0;i<texunit_pair_count;i++) {
glUniform1i(texunit_pairs[i].location, texunit_pairs[i].index);
DEBUG_TEST_ERROR("Uniform 1 i");
}
*/
return true;
}
void ShaderGLES2::unbind() {
version=NULL;
glUseProgram(0);
uniforms_dirty = true;
active=NULL;
}
static String _fix_error_code_line(const String& p_error,int p_code_start,int p_offset) {
int last_find_pos=-1;
// NVIDIA
String error=p_error;
while((last_find_pos=p_error.find("(",last_find_pos+1))!=-1) {
int end_pos=last_find_pos+1;
while(true) {
if (p_error[end_pos]>='0' && p_error[end_pos]<='9') {
end_pos++;
continue;
} else if (p_error[end_pos]==')') {
break;
} else {
end_pos=-1;
break;
}
}
if (end_pos==-1)
continue;
String numstr = error.substr(last_find_pos+1,(end_pos-last_find_pos)-1);
String begin = error.substr(0,last_find_pos+1);
String end = error.substr(end_pos,error.length());
int num = numstr.to_int()+p_code_start-p_offset;
error = begin+itos(num)+end;
}
// ATI
last_find_pos=-1;
while((last_find_pos=p_error.find("ERROR: ",last_find_pos+1))!=-1) {
last_find_pos+=6;
int end_pos=last_find_pos+1;
while(true) {
if (p_error[end_pos]>='0' && p_error[end_pos]<='9') {
end_pos++;
continue;
} else if (p_error[end_pos]==':') {
break;
} else {
end_pos=-1;
break;
}
}
continue;
if (end_pos==-1)
continue;
String numstr = error.substr(last_find_pos+1,(end_pos-last_find_pos)-1);
print_line("numstr: "+numstr);
String begin = error.substr(0,last_find_pos+1);
String end = error.substr(end_pos,error.length());
int num = numstr.to_int()+p_code_start-p_offset;
error = begin+itos(num)+end;
}
return error;
}
ShaderGLES2::Version* ShaderGLES2::get_current_version() {
Version *_v=version_map.getptr(conditional_version);
if (_v) {
if (conditional_version.code_version!=0) {
CustomCode *cc=custom_code_map.getptr(conditional_version.code_version);
ERR_FAIL_COND_V(!cc,_v);
if (cc->version==_v->code_version)
return _v;
} else {
return _v;
}
}
if (!_v)
version_map[conditional_version]=Version();
Version &v = version_map[conditional_version];
if (!_v) {
v.uniform_location = memnew_arr( GLint, uniform_count );
} else {
if (v.ok) {
//bye bye shaders
glDeleteShader( v.vert_id );
glDeleteShader( v.frag_id );
glDeleteProgram( v.id );
v.id=0;
}
}
v.ok=false;
/* SETUP CONDITIONALS */
Vector<const char*> strings;
#ifdef GLEW_ENABLED
strings.push_back("#version 120\n"); //ATI requieres this before anything
#endif
int define_line_ofs=1;
for(int j=0;j<conditional_count;j++) {
bool enable=((1<<j)&conditional_version.version);
strings.push_back(enable?conditional_defines[j]:"");
if (enable)
define_line_ofs++;
if (enable) {
DEBUG_PRINT(conditional_defines[j]);
}
}
//keep them around during the function
CharString code_string;
CharString code_string2;
CharString code_globals;
//print_line("code version? "+itos(conditional_version.code_version));
CustomCode *cc=NULL;
if ( conditional_version.code_version>0 ) {
//do custom code related stuff
ERR_FAIL_COND_V( !custom_code_map.has( conditional_version.code_version ), NULL );
cc=&custom_code_map[conditional_version.code_version];
v.code_version=cc->version;
define_line_ofs+=2;
}
/* CREATE PROGRAM */
v.id = glCreateProgram();
ERR_FAIL_COND_V(v.id==0, NULL);
/* VERTEX SHADER */
if (cc) {
for(int i=0;i<cc->custom_defines.size();i++) {
strings.push_back(cc->custom_defines[i]);
DEBUG_PRINT("CD #"+itos(i)+": "+String(cc->custom_defines[i]));
}
}
int strings_base_size=strings.size();
#if 0
if (cc) {
String _code_string = "#define VERTEX_SHADER_CODE "+cc->vertex+"\n";
String _code_globals = "#define VERTEX_SHADER_GLOBALS "+cc->vertex_globals+"\n";
code_string=_code_string.ascii();
code_globals=_code_globals.ascii();
DEBUG_PRINT( code_globals.get_data() );
DEBUG_PRINT( code_string.get_data() );
strings.push_back(code_globals);
strings.push_back(code_string);
}
#endif
strings.push_back(vertex_code0.get_data());
if (cc) {
code_globals=cc->vertex_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(vertex_code1.get_data());
if (cc) {
code_string=cc->vertex.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(vertex_code2.get_data());
#ifdef DEBUG_SHADER
DEBUG_PRINT("\nVertex Code:\n\n"+String(code_string.get_data()));
for(int i=0;i<strings.size();i++) {
//print_line("vert strings "+itos(i)+":"+String(strings[i]));
}
#endif
v.vert_id = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(v.vert_id,strings.size(),&strings[0],NULL);
glCompileShader(v.vert_id);
GLint status;
glGetShaderiv(v.vert_id,GL_COMPILE_STATUS,&status);
if (status==GL_FALSE) {
// error compiling
GLsizei iloglen;
glGetShaderiv(v.vert_id,GL_INFO_LOG_LENGTH,&iloglen);
if (iloglen<0) {
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
ERR_PRINT("NO LOG, WTF");
} else {
if (iloglen==0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
ilogmem[iloglen]=0;
glGetShaderInfoLog(v.vert_id, iloglen, &iloglen, ilogmem);
String err_string=get_shader_name()+": Vertex Program Compilation Failed:\n";
err_string+=ilogmem;
err_string=_fix_error_code_line(err_string,vertex_code_start,define_line_ofs);
ERR_PRINT(err_string.ascii().get_data());
Memory::free_static(ilogmem);
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
}
ERR_FAIL_V(NULL);
}
/* FRAGMENT SHADER */
strings.resize(strings_base_size);
#if 0
if (cc) {
String _code_string = "#define FRAGMENT_SHADER_CODE "+cc->fragment+"\n";
String _code_globals = "#define FRAGMENT_SHADER_GLOBALS "+cc->fragment_globals+"\n";
code_string=_code_string.ascii();
code_globals=_code_globals.ascii();
DEBUG_PRINT( code_globals.get_data() );
DEBUG_PRINT( code_string.get_data() );
strings.push_back(code_globals);
strings.push_back(code_string);
}
#endif
strings.push_back(fragment_code0.get_data());
if (cc) {
code_globals=cc->fragment_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(fragment_code1.get_data());
if (cc) {
code_string=cc->fragment.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(fragment_code2.get_data());
if (cc) {
code_string2=cc->light.ascii();
strings.push_back(code_string2.get_data());
}
strings.push_back(fragment_code3.get_data());
#ifdef DEBUG_SHADER
DEBUG_PRINT("\nFragment Code:\n\n"+String(code_string.get_data()));
for(int i=0;i<strings.size();i++) {
//print_line("frag strings "+itos(i)+":"+String(strings[i]));
}
#endif
v.frag_id = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(v.frag_id,strings.size(),&strings[0],NULL);
glCompileShader(v.frag_id);
glGetShaderiv(v.frag_id,GL_COMPILE_STATUS,&status);
if (status==GL_FALSE) {
// error compiling
GLsizei iloglen;
glGetShaderiv(v.frag_id,GL_INFO_LOG_LENGTH,&iloglen);
if (iloglen<0) {
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
ERR_PRINT("NO LOG, WTF");
} else {
if (iloglen==0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
ilogmem[iloglen]=0;
glGetShaderInfoLog(v.frag_id, iloglen, &iloglen, ilogmem);
String err_string=get_shader_name()+": Fragment Program Compilation Failed:\n";
err_string+=ilogmem;
err_string=_fix_error_code_line(err_string,fragment_code_start,define_line_ofs);
ERR_PRINT(err_string.ascii().get_data());
Memory::free_static(ilogmem);
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
}
ERR_FAIL_V( NULL );
}
glAttachShader(v.id,v.frag_id);
glAttachShader(v.id,v.vert_id);
// bind attributes before linking
for (int i=0;i<attribute_pair_count;i++) {
glBindAttribLocation(v.id, attribute_pairs[i].index, attribute_pairs[i].name );
}
glLinkProgram(v.id);
glGetProgramiv(v.id, GL_LINK_STATUS, &status);
if (status==GL_FALSE) {
// error linking
GLsizei iloglen;
glGetProgramiv(v.id,GL_INFO_LOG_LENGTH,&iloglen);
if (iloglen<0) {
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
ERR_FAIL_COND_V(iloglen<=0, NULL);
}
if (iloglen==0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
ilogmem[iloglen]=0;
glGetProgramInfoLog(v.id, iloglen, &iloglen, ilogmem);
String err_string=get_shader_name()+": Program LINK FAILED:\n";
err_string+=ilogmem;
err_string=_fix_error_code_line(err_string,fragment_code_start,define_line_ofs);
ERR_PRINT(err_string.ascii().get_data());
Memory::free_static(ilogmem);
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
glDeleteProgram( v.id );
v.id=0;
ERR_FAIL_V(NULL);
}
/* UNIFORMS */
glUseProgram(v.id);
//print_line("uniforms: ");
for(int j=0;j<uniform_count;j++) {
v.uniform_location[j]=glGetUniformLocation(v.id,uniform_names[j]);
// print_line("uniform "+String(uniform_names[j])+" location "+itos(v.uniform_location[j]));
}
// set texture uniforms
for (int i=0;i<texunit_pair_count;i++) {
GLint loc = glGetUniformLocation(v.id,texunit_pairs[i].name);
if (loc>=0)
glUniform1i(loc,texunit_pairs[i].index);
}
if ( cc ) {
v.custom_uniform_locations.resize(cc->custom_uniforms.size());
for(int i=0;i<cc->custom_uniforms.size();i++) {
v.custom_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->custom_uniforms[i]).ascii().get_data());
}
}
glUseProgram(0);
v.ok=true;
return &v;
}
GLint ShaderGLES2::get_uniform_location(const String& p_name) const {
ERR_FAIL_COND_V(!version,-1);
return glGetUniformLocation(version->id,p_name.ascii().get_data());
}
void ShaderGLES2::setup(const char** p_conditional_defines, int p_conditional_count,const char** p_uniform_names,int p_uniform_count, const AttributePair* p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count,const char*p_vertex_code, const char *p_fragment_code,int p_vertex_code_start,int p_fragment_code_start) {
ERR_FAIL_COND(version);
conditional_version.key=0;
new_conditional_version.key=0;
uniform_count=p_uniform_count;
conditional_count=p_conditional_count;
conditional_defines=p_conditional_defines;
uniform_names=p_uniform_names;
vertex_code=p_vertex_code;
fragment_code=p_fragment_code;
texunit_pairs=p_texunit_pairs;
texunit_pair_count=p_texunit_pair_count;
vertex_code_start=p_vertex_code_start;
fragment_code_start=p_fragment_code_start;
attribute_pairs=p_attribute_pairs;
attribute_pair_count=p_attribute_count;
//split vertex and shader code (thank you, retarded shader compiler programmers from you know what company).
{
String globals_tag="\nVERTEX_SHADER_GLOBALS";
String code_tag="\nVERTEX_SHADER_CODE";
String code = vertex_code;
int cpos = code.find(globals_tag);
if (cpos==-1) {
vertex_code0=code.ascii();
} else {
vertex_code0=code.substr(0,cpos).ascii();
code = code.substr(cpos+globals_tag.length(),code.length());
cpos = code.find(code_tag);
if (cpos==-1) {
vertex_code1=code.ascii();
} else {
vertex_code1=code.substr(0,cpos).ascii();
vertex_code2=code.substr(cpos+code_tag.length(),code.length()).ascii();
}
}
}
{
String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
String code_tag="\nFRAGMENT_SHADER_CODE";
String light_code_tag="\nLIGHT_SHADER_CODE";
String code = fragment_code;
int cpos = code.find(globals_tag);
if (cpos==-1) {
fragment_code0=code.ascii();
} else {
fragment_code0=code.substr(0,cpos).ascii();
code = code.substr(cpos+globals_tag.length(),code.length());
cpos = code.find(code_tag);
if (cpos==-1) {
fragment_code1=code.ascii();
} else {
fragment_code1=code.substr(0,cpos).ascii();
String code2 = code.substr(cpos+code_tag.length(),code.length());
cpos = code2.find(light_code_tag);
if (cpos==-1) {
fragment_code2=code2.ascii();
} else {
fragment_code2=code2.substr(0,cpos).ascii();
fragment_code3 = code2.substr(cpos+light_code_tag.length(),code2.length()).ascii();
}
}
}
}
}
void ShaderGLES2::finish() {
const VersionKey *V=NULL;
while((V=version_map.next(V))) {
Version &v=version_map[*V];
glDeleteShader( v.vert_id );
glDeleteShader( v.frag_id );
glDeleteProgram( v.id );
memdelete_arr( v.uniform_location );
}
}
void ShaderGLES2::clear_caches() {
const VersionKey *V=NULL;
while((V=version_map.next(V))) {
Version &v=version_map[*V];
glDeleteShader( v.vert_id );
glDeleteShader( v.frag_id );
glDeleteProgram( v.id );
memdelete_arr( v.uniform_location );
}
version_map.clear();
custom_code_map.clear();
version=NULL;
last_custom_code=1;
uniforms_dirty = true;
}
uint32_t ShaderGLES2::create_custom_shader() {
custom_code_map[last_custom_code]=CustomCode();
custom_code_map[last_custom_code].version=1;
return last_custom_code++;
}
void ShaderGLES2::set_custom_shader_code(uint32_t p_code_id, const String& p_vertex, const String& p_vertex_globals,const String& p_fragment,const String& p_light, const String& p_fragment_globals,const Vector<StringName>& p_uniforms,const Vector<const char*> &p_custom_defines) {
ERR_FAIL_COND(!custom_code_map.has(p_code_id));
CustomCode *cc=&custom_code_map[p_code_id];
cc->vertex=p_vertex;
cc->vertex_globals=p_vertex_globals;
cc->fragment=p_fragment;
cc->fragment_globals=p_fragment_globals;
cc->light=p_light;
cc->custom_uniforms=p_uniforms;
cc->custom_defines=p_custom_defines;
cc->version++;
}
void ShaderGLES2::set_custom_shader(uint32_t p_code_id) {
new_conditional_version.code_version=p_code_id;
}
void ShaderGLES2::free_custom_shader(uint32_t p_code_id) {
/* if (! custom_code_map.has( p_code_id )) {
print_line("no code id "+itos(p_code_id));
} else {
print_line("freed code id "+itos(p_code_id));
}*/
ERR_FAIL_COND(! custom_code_map.has( p_code_id ));
if (conditional_version.code_version==p_code_id)
conditional_version.code_version=0; //bye
custom_code_map.erase(p_code_id);
}
ShaderGLES2::ShaderGLES2() {
version=NULL;
last_custom_code=1;
uniforms_dirty = true;
}
ShaderGLES2::~ShaderGLES2() {
finish();
}
#endif
Reference in a new issue View git blame Copy permalink