virtualx-engine/drivers/gles3/shader_gles3.cpp

/*************************************************************************/
/*  shader_gles2.cpp                                                     */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2016 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_gles3.h"


#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

ShaderGLES3 *ShaderGLES3::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 ShaderGLES3::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 ShaderGLES3::get_uniform_location(int p_idx) const {

	ERR_FAIL_COND_V(!version, -1);

	return version->uniform_location[p_idx];
};

bool ShaderGLES3::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 ShaderGLES3::unbind() {

	version=NULL;
	glUseProgram(0);
	uniforms_dirty = true;
	active=NULL;
}


static void _display_error_with_code(const String& p_error,const Vector<const char*>& p_code) {


	int line=1;
	String total_code;

	for(int i=0;i<p_code.size();i++) {
		total_code+=String(p_code[i]);
	}

	Vector<String> lines = String(total_code).split("\n");

	for(int j=0;j<lines.size();j++) {

		print_line(itos(line)+": "+lines[j]);
		line++;
	}

	ERR_PRINTS(p_error);

}

ShaderGLES3::Version* ShaderGLES3::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 GLES_OVER_GL
	strings.push_back("#version 330\n");
#else
	strings.push_back("#version 300 es\n");
#endif



	int define_line_ofs=1;

	for(int i=0;i<custom_defines.size();i++) {

		strings.push_back(custom_defines[i].get_data());
		define_line_ofs++;
	}

	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;
	CharString material_string;


	//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].get_data());
			DEBUG_PRINT("CD #"+itos(i)+": "+String(cc->custom_defines[i]));
		}
	}

	int strings_base_size=strings.size();

	//vertex precision is high
	strings.push_back("precision highp float;\n");
	strings.push_back("precision highp int;\n");

#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) {
		material_string=cc->uniforms.ascii();
		strings.push_back(material_string.get_data());
	}

	strings.push_back(vertex_code2.get_data());

	if (cc) {
		code_string=cc->vertex.ascii();
		strings.push_back(code_string.get_data());
	}

	strings.push_back(vertex_code3.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;
			_display_error_with_code(err_string,strings);
			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);
	//fragment precision is medium
	strings.push_back("precision mediump float;\n");
	strings.push_back("precision mediump int;\n");

#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) {
		material_string=cc->uniforms.ascii();
		strings.push_back(material_string.get_data());
	}

	strings.push_back(fragment_code2.get_data());

	if (cc) {
		code_string=cc->fragment.ascii();
		strings.push_back(code_string.get_data());
	}

	strings.push_back(fragment_code3.get_data());

	if (cc) {
		code_string2=cc->light.ascii();
		strings.push_back(code_string2.get_data());
	}

	strings.push_back(fragment_code4.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;
			_display_error_with_code(err_string,strings);
			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;
		_display_error_with_code(err_string,strings);
		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) {
			if (texunit_pairs[i].index<0) {
				glUniform1i(loc,max_image_units+texunit_pairs[i].index); //negative, goes down
			} else {

				glUniform1i(loc,texunit_pairs[i].index);
			}
		}
	}

	// assign uniform block bind points
	for (int i=0;i<ubo_count;i++) {

		GLint loc =  glGetUniformBlockIndex(v.id,ubo_pairs[i].name);
		if (loc>=0)
			 glUniformBlockBinding(v.id,loc,ubo_pairs[i].index);
	}

	if ( cc ) {

		v.texture_uniform_locations.resize(cc->texture_uniforms.size());
		for(int i=0;i<cc->texture_uniforms.size();i++) {

			v.texture_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->texture_uniforms[i]).ascii().get_data());
			glUniform1i(v.texture_uniform_locations[i],i+base_material_tex_index);
		}
	}

	glUseProgram(0);
	

	v.ok=true;

	return &v;
}

GLint ShaderGLES3::get_uniform_location(const String& p_name) const {

	ERR_FAIL_COND_V(!version,-1);
	return glGetUniformLocation(version->id,p_name.ascii().get_data());
}


void ShaderGLES3::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 UBOPair *p_ubo_pairs, int p_ubo_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;
	ubo_pairs=p_ubo_pairs;
	ubo_count=p_ubo_pair_count;

	//split vertex and shader code (thank you, retarded shader compiler programmers from you know what company).
	{
		String globals_tag="\nVERTEX_SHADER_GLOBALS";
		String material_tag="\nMATERIAL_UNIFORMS";
		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(material_tag);

			if (cpos==-1) {
				vertex_code1=code.ascii();
			} else {

				vertex_code1=code.substr(0,cpos).ascii();
				String code2 = code.substr(cpos+material_tag.length(),code.length());

				cpos = code2.find(code_tag);
				if (cpos==-1) {
					vertex_code2=code2.ascii();
				} else {

					vertex_code2=code2.substr(0,cpos).ascii();
					vertex_code3 = code2.substr(cpos+code_tag.length(),code2.length()).ascii();
				}

			}
		}
	}

	{
		String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
		String material_tag="\nMATERIAL_UNIFORMS";
		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();
			//print_line("CODE0:\n"+String(fragment_code0.get_data()));
			code = code.substr(cpos+globals_tag.length(),code.length());			
			cpos = code.find(material_tag);

			if (cpos==-1) {
				fragment_code1=code.ascii();
			} else {

				fragment_code1=code.substr(0,cpos).ascii();
				//print_line("CODE1:\n"+String(fragment_code1.get_data()));

				String code2 = code.substr(cpos+material_tag.length(),code.length());
				cpos = code2.find(code_tag);

				if (cpos==-1) {
					fragment_code2=code2.ascii();
				} else {

					fragment_code2=code2.substr(0,cpos).ascii();
					//print_line("CODE2:\n"+String(fragment_code2.get_data()));

					String code3 = code2.substr(cpos+code_tag.length(),code2.length());

					cpos = code3.find(light_code_tag);
					if (cpos==-1) {
						fragment_code3=code3.ascii();
					} else {

						fragment_code3=code3.substr(0,cpos).ascii();
					//	print_line("CODE3:\n"+String(fragment_code3.get_data()));
						fragment_code4 = code3.substr(cpos+light_code_tag.length(),code3.length()).ascii();
						//print_line("CODE4:\n"+String(fragment_code4.get_data()));
					}
				}
			}
		}
	}

	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&max_image_units);

}

void ShaderGLES3::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 ShaderGLES3::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 ShaderGLES3::create_custom_shader() {

	custom_code_map[last_custom_code]=CustomCode();
	custom_code_map[last_custom_code].version=1;
	return last_custom_code++;
}

void ShaderGLES3::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 String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &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->texture_uniforms=p_texture_uniforms;
	cc->uniforms=p_uniforms;
	cc->custom_defines=p_custom_defines;
	cc->version++;
}

void ShaderGLES3::set_custom_shader(uint32_t p_code_id) {

	new_conditional_version.code_version=p_code_id;
}

void ShaderGLES3::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);

}

void ShaderGLES3::set_base_material_tex_index(int p_idx) {

	base_material_tex_index=p_idx;
}

ShaderGLES3::ShaderGLES3() {
	version=NULL;
	last_custom_code=1;
	uniforms_dirty = true;
	base_material_tex_index=0;

}


ShaderGLES3::~ShaderGLES3() {
	
	finish();
}