30 static char *GLshader_info_log = NULL;
31 static const int GLshader_info_log_size = 8192;
34 static int GL_anim_effect_num = 0;
35 static float GL_anim_timer = 0.0f;
45 0, {}, 0, {},
"Model Rendering" },
48 7, {
"baseMap",
"depthMap",
"window_width",
"window_height",
"nearZ",
"farZ",
"linear_depth" }, 1, {
"radius"},
"Particle Effects" },
51 6, {
"baseMap",
"window_width",
"window_height",
"distMap",
"frameBuffer",
"use_offset" }, 1, {
"radius" },
"Distortion Effects" },
54 5, {
"tex",
"depth_tex",
"timer",
"bloomed",
"bloom_intensity" }, 0, { NULL },
"Post Processing" },
57 2, {
"tex",
"bsize",
"debug" }, 0, { NULL },
"Gaussian Blur" },
60 1, {
"tex" }, 0, { NULL },
"Bloom Brightpass" },
63 3, {
"tex0",
"rt_w",
"rt_h" }, 0, { NULL },
"FXAA" },
66 1, {
"tex" }, 0, { NULL },
"FXAA Prepass" },
69 8, {
"scene",
"cockpit",
"sun_pos",
"weight",
"intensity",
"falloff",
"density",
"cp_intensity" }, 0, { NULL },
"Lightshafts" },
72 16, {
"scale",
"ColorBuffer",
"NormalBuffer",
"PositionBuffer",
"SpecBuffer",
"invScreenWidth",
"invScreenHeight",
"lightType",
"lightRadius",
"diffuseLightColor",
73 "specLightColor",
"dualCone",
"coneDir",
"coneAngle",
"coneInnerAngle",
"specFactor" }, 0, { NULL },
"Deferred Lighting" },
76 0, { NULL }, 0, { NULL },
"Clear Deferred Lighting Buffer" },
79 3, {
"ytex",
"utex",
"vtex" }, 0, { NULL },
"Video Playback" }
88 2, {
"n_lights",
"light_factor" }, 0, { NULL },
92 0, { NULL }, 0, { NULL },
96 4, {
"sBasemap",
"desaturate",
"desaturate_clr",
"blend_alpha" }, 0, { NULL },
100 1, {
"sGlowmap" }, 0, { NULL },
104 1, {
"sSpecmap" }, 0, { NULL },
105 "Specular Mapping" },
108 1, {
"sNormalmap" }, 0, { NULL },
112 1, {
"sHeightmap" }, 0, { NULL },
113 "Parallax Mapping" },
116 3, {
"sEnvmap",
"alpha_spec",
"envMatrix" }, 0, { NULL },
117 "Environment Mapping" },
120 5, {
"sFramebuffer",
"effect_num",
"anim_timer",
"vpwidth",
"vpheight" }, 0, { NULL },
121 "Animated Effects" },
124 1, {
"sMiscmap" }, 0, { NULL },
128 3, {
"stripe_color",
"base_color",
"team_glow_enabled" }, 0, { NULL },
132 0, { NULL }, 0, { NULL },
133 "Deferred lighting" },
136 1, {
"shadow_proj_matrix" }, 0, { NULL },
140 8, {
"shadow_map",
"shadow_mv_matrix",
"shadow_proj_matrix",
"model_matrix",
"veryneardist",
"neardist",
"middist",
"fardist" }, 0, { NULL },
144 1, {
"thruster_scale" }, 0, { NULL },
145 "Thruster scaling" },
148 2, {
"transform_tex",
"buffer_matrix_offset" }, 1, {
"model_id" },
149 "Submodel Transforms" },
152 4, {
"use_clip_plane",
"world_matrix",
"clip_normal",
"clip_position" }, 0, { NULL },
156 0, { NULL }, 1, {
"uvec" },
157 "Geometry shader point-based particles" },
160 0, { NULL }, 0, { NULL },
161 "Horizontal blur pass" },
164 0, { NULL }, 0, { NULL },
165 "Vertical blur pass" }
182 if (shader_obj != NULL) {
184 Current_shader = shader_obj;
191 GLint obj_status = 0;
197 mprintf((
"VALIDATE INFO-LOG:\n"));
199 if (strlen(GLshader_info_log) > 5) {
200 mprintf((
"%s\n", GLshader_info_log));
209 Current_shader = NULL;
217 Assert(handle < (
int)GL_shader.size());
235 size_t max = GL_shader.size();
237 for (idx = 0; idx < max; idx++) {
238 if (GL_shader[idx].
shader == shader_t && GL_shader[idx].flags == flags) {
250 Assert(sdr_handle < (
int)GL_shader.size());
252 if (GL_shader[sdr_handle].program_id) {
254 GL_shader[sdr_handle].program_id = 0;
257 GL_shader[sdr_handle].flags = 0;
258 GL_shader[sdr_handle].flags2 = 0;
261 GL_shader[sdr_handle].uniforms.clear();
262 GL_shader[sdr_handle].attributes.clear();
263 GL_shader[sdr_handle].uniform_blocks.clear();
277 for (i = 0; i < GL_shader.size(); i++) {
278 if (GL_shader[i].program_id) {
280 GL_shader[
i].program_id = 0;
283 GL_shader[
i].uniforms.clear();
284 GL_shader[
i].attributes.clear();
285 GL_shader[
i].uniform_blocks.clear();
290 if (GLshader_info_log != NULL) {
292 GLshader_info_log = NULL;
300 sflags <<
"#version 120\n";
301 sflags <<
"#define APPLE\n";
309 for (
int i = 0;
i < GL_num_shader_variants; ++
i) {
312 if (type_id == variant.
type_id && flags & variant.
flag) {
313 sflags <<
"#define " << variant.
flag_text <<
"\n";
337 if (cf_shader != NULL) {
341 cfread(&content[0], len + 1, 1, cf_shader);
349 mprintf((
" Loading built-in default shader for: %s\n", filename));
351 content.assign(def_shader);
358 parts.push_back(get_shader_header(type_id, flags));
360 parts.push_back(opengl_load_shader(filename));
382 mprintf((
"Compiling new shader:\n"));
386 bool use_geo_sdr =
false;
389 if ( sdr_info->
geo != NULL ) {
390 for (
int i = 0;
i < GL_num_shader_variants; ++
i) {
400 auto vertex_content = opengl_get_shader_content(sdr_info->
type_id, sdr_info->
vert, flags);
401 auto fragment_content = opengl_get_shader_content(sdr_info->
type_id, sdr_info->
frag, flags);
410 geom_content = opengl_get_shader_content(sdr_info->
type_id, sdr_info->
geo, flags);
440 mprintf((
"Shader Variant Features:\n"));
443 for (
int i = 0;
i < GL_num_shader_variants; ++
i ) {
464 for (
int i = 0;
i < (
int)GL_shader.size(); ++
i ) {
472 if ( empty_idx >= 0 ) {
473 GL_shader[empty_idx] = new_shader;
474 sdr_index = empty_idx;
476 sdr_index = GL_shader.size();
477 GL_shader.push_back(new_shader);
509 GL_shader.reserve(32);
528 if (GLshader_info_log == NULL) {
529 GLshader_info_log = (
char *)
vm_malloc(GLshader_info_log_size);
532 memset(GLshader_info_log, 0, GLshader_info_log_size);
534 vglGetInfoLogARB(shader_object, GLshader_info_log_size-1, 0, GLshader_info_log);
552 sources.reserve(shader_source.size());
553 for (
auto it = shader_source.begin(); it != shader_source.end(); ++it) {
554 sources.push_back(it->c_str());
581 if (strlen(GLshader_info_log) > 5) {
585 return shader_object;
610 if (fragment_object) {
614 if (geometry_object) {
617 if ( Current_geo_sdr_params != NULL) {
638 mprintf((
"Shader failed to link:\n%s\n", GLshader_info_log));
648 if (strlen(GLshader_info_log) > 5) {
649 nprintf((
"SHADER-DEBUG",
"Shader linked with warnings:\n%s\n", GLshader_info_log));
652 return shader_object;
674 mprintf((
"ERROR! Unable to create vertex shader!\n"));
683 mprintf((
"ERROR! Unable to create fragment shader!\n"));
692 mprintf((
"ERROR! Unable to create fragment shader!\n"));
700 mprintf((
"ERROR! Unable to create shader program!\n"));
728 if ( ( Current_shader == NULL ) || ( attribute_text == NULL ) ) {
733 new_attribute.
text_id = attribute_text;
737 nprintf((
"SHADER-DEBUG",
"WARNING: Unable to get shader attribute location for \"%s\"!\n", attribute_text));
741 Current_shader->
attributes.push_back( new_attribute );
752 if ( (Current_shader == NULL) || (attribute_text == NULL) ) {
759 for (attribute = Current_shader->
attributes.begin(); attribute != Current_shader->
attributes.end(); ++attribute) {
760 if ( !attribute->text_id.compare(attribute_text) ) {
761 return attribute->location;
777 if ( (Current_shader == NULL) || (uniform_text == NULL) ) {
782 new_uniform.
text_id = uniform_text;
786 nprintf((
"SHADER-DEBUG",
"WARNING: Unable to get shader uniform location for \"%s\"!\n", uniform_text));
790 Current_shader->
uniforms.push_back( new_uniform );
801 if ( (Current_shader == NULL) || (uniform_text == NULL) ) {
809 for (uniform = Current_shader->
uniforms.begin(); uniform != uniforms_end; ++uniform) {
810 if ( !uniform->text_id.compare(uniform_text) ) {
811 return uniform->location;
827 if ( (Current_shader == NULL) || (uniform_text == NULL) ) {
832 new_uniform_block.
text_id = uniform_text;
838 if (new_uniform_block.
location < 0) {
839 nprintf((
"SHADER-DEBUG",
"WARNING: Unable to get shader uniform block location for \"%s\"!\n", uniform_text));
854 if ( (Current_shader == NULL) || (uniform_text == NULL) ) {
862 if ( !uniform_block->text_id.compare(uniform_text) ) {
863 return uniform_block->location;
878 GL_anim_effect_num = effect;
879 GL_anim_timer = timer;
889 return GL_anim_effect_num;
897 return GL_anim_timer;
905 bool in_error =
false;
909 if ( sdr_handle >= 0 ) {
921 mprintf((
"Failed to compile deferred lighting shader!\n"));
926 mprintf((
"Failed to compile deferred lighting buffer clear shader!\n"));
931 mprintf((
" Shader in_error! Disabling deferred lighting!\n"));
#define vglShaderSourceARB
#define OGL_EXT_GEOMETRY_SHADER4
#define vglProgramParameteriEXT
#define GL_GEOMETRY_VERTICES_OUT_EXT
void opengl_shader_compile_deferred_light_shader()
#define vglGetUniformBlockIndexARB
LOCAL state_stack gs[GS_STACK_SIZE]
void opengl_post_shader_header(SCP_stringstream &sflags, shader_type shader_t, int flags)
int cfread(void *buf, int elsize, int nelem, CFILE *fp)
std::basic_stringstream< char, std::char_traits< char >, std::allocator< char > > SCP_stringstream
GLint opengl_shader_get_uniform(const char *uniform_text)
#define SDR_FLAG_MODEL_CLIP
#define vglCompileShaderARB
char * uniforms[MAX_SHADER_UNIFORMS]
#define SDR_FLAG_MODEL_DIFFUSE_MAP
#define vglGetUniformLocationARB
const char * defaults_get_file(const char *filename)
SCP_vector< opengl_shader_t > GL_shader
#define SDR_FLAG_MODEL_DEFERRED
opengl_texture_state Texture
#define GL_FRAGMENT_SHADER_ARB
std::basic_string< char, std::char_traits< char >, std::allocator< char > > SCP_string
GLint opengl_shader_get_uniform_block(const char *uniform_text)
#define SDR_FLAG_MODEL_LIGHT
#define GL_TEXTURE_WRAP_S
#define vglGetAttribLocationARB
#define SDR_FLAG_MODEL_FOG
GLint opengl_shader_get_attribute(const char *attribute_text)
opengl_shader_t * Current_shader
#define SDR_FLAG_PARTICLE_POINT_GEN
void opengl_delete_shader(int sdr_handle)
void opengl_shader_init_uniform(const char *uniform_text)
#define SDR_FLAG_MODEL_MISC_MAP
typedef int(SCP_EXT_CALLCONV *SCPDLL_PFVERSION)(SCPDLL_Version *)
#define SDR_FLAG_MODEL_SPEC_MAP
#define GL_OBJECT_VALIDATE_STATUS_ARB
void opengl_shader_shutdown()
void opengl_shader_init_uniform_block(const char *uniform_text)
#define SDR_FLAG_MODEL_SHADOW_MAP
WINGDIAPI void APIENTRY glGenTextures(GLsizei n, GLuint *textures)
WINGDIAPI void APIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
#define vglValidateProgramARB
#define SDR_FLAG_MODEL_NORMAL_MAP
#define GL_TEXTURE_WRAP_R
#define GL_TEXTURE_MAG_FILTER
opengl_uniform_state Uniform
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
#define Is_Extension_Enabled(x)
char * uniforms[MAX_SHADER_UNIFORMS]
void SetTarget(GLenum tex_target)
int Cmdline_no_deferred_lighting
void Enable(GLuint tex_id=0)
char * attributes[MAX_SDR_ATTRIBUTES]
GLuint Framebuffer_fallback_texture_id
SCP_vector< opengl_shader_uniform_t > uniform_blocks
#define GL_GEOMETRY_OUTPUT_TYPE_EXT
float opengl_shader_get_animated_timer()
#define SDR_FLAG_MODEL_TEAMCOLOR
int opengl_compile_shader(shader_type sdr, uint flags)
#define GL_UNSIGNED_INT_8_8_8_8_REV
#define SDR_FLAG_MODEL_GLOW_MAP
#define vglCreateShaderObjectARB
#define SDR_FLAG_MODEL_ENV_MAP
#define GL_TEXTURE_WRAP_T
int gr_opengl_maybe_create_shader(shader_type shader_t, unsigned int flags)
#define SDR_FLAG_BLUR_HORIZONTAL
#define SDR_FLAG_MODEL_HEIGHT_MAP
#define GL_OBJECT_LINK_STATUS_ARB
SCP_vector< opengl_shader_uniform_t > attributes
int opengl_shader_get_animated_effect()
#define GL_TEXTURE_MIN_FILTER
#define GL_VERTEX_SHADER_ARB
GLhandleARB opengl_shader_link_object(GLhandleARB vertex_object, GLhandleARB fragment_object, GLhandleARB geometry_object)
void opengl_shader_check_info_log(GLhandleARB shader_object)
#define GL_GEOMETRY_INPUT_TYPE_EXT
GLhandleARB opengl_shader_compile_object(const SCP_vector< SCP_string > &shader_source, GLenum shader_type)
#define SDR_FLAG_MODEL_SHADOWS
void opengl_shader_init_attribute(const char *attribute_text)
#define GL_GEOMETRY_SHADER_EXT
#define vglAttachObjectARB
GLhandleARB opengl_shader_create(const SCP_vector< SCP_string > &vs, const SCP_vector< SCP_string > &fs, const SCP_vector< SCP_string > &gs)
SCP_vector< opengl_shader_uniform_t > uniforms
char * attributes[MAX_SDR_ATTRIBUTES]
void opengl_shader_init()
WINGDIAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
#define SDR_FLAG_MODEL_ANIMATED
#define SDR_FLAG_BLUR_VERTICAL
bool is_minimum_GLSL_version()
bool Enable_external_shaders
void opengl_shader_set_current(opengl_shader_t *shader_obj)
#define GL_OBJECT_COMPILE_STATUS_ARB
geometry_sdr_params * Current_geo_sdr_params
int cfclose(CFILE *cfile)
#define SDR_FLAG_MODEL_TRANSFORM
#define vglCreateProgramObjectARB
#define vglUseProgramObjectARB
#define vglDeleteObjectARB
#define SDR_FLAG_MODEL_THRUSTER
int cfilelength(CFILE *cfile)
void gr_opengl_shader_set_animated_effect(int effect, float timer)
void SetActiveUnit(GLuint id=0)
int opengl_check_for_errors(char *err_at)
void opengl_post_init_uniforms(int flags)
geometry_sdr_params geo_sdr_info
#define GL_TRIANGLE_STRIP
#define vglLinkProgramARB
#define vglGetObjectParameterivARB