blender
/
blender
137
404
Fork 586
Code Issues 6.2k Pull Requests 756 Projects 19 Wiki Activity

OpenGL: remove non-GLSL option from basic shader 

This code path was only used when Blender was launched with --enable-legacy-basic-shader at the command line.

Part of general OpenGL upgrade (T49165)
This commit is contained in:
Mike Erwin 2017-03-15 11:52:54 -04:00
parent 8892c7869e
commit fce0ff0a31
3 changed files with 17 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
source/blender/gpu/GPU_basic_shader.h
View File

@ -126,9 +126,6 @@ void GPU_basic_shader_stipple(GPUBasicShaderStipple stipple_id);
void GPU_basic_shader_line_stipple(GLint stipple_factor, GLushort stipple_pattern);
void GPU_basic_shader_line_width(float line_width);
bool GPU_basic_shader_use_glsl_get(void);
void GPU_basic_shader_use_glsl_set(bool enabled);
#ifdef __cplusplus
}
#endif

160
source/blender/gpu/intern/gpu_basic_shader.c
View File

@ -159,24 +159,6 @@ const GLubyte stipple_hexagon[128] = {
0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22};
/* ********************************************* */
/* GLSL State */
static bool USE_GLSL = true;
/**
* \note this isn't part of the basic shader API,
* only set from the command line once on startup.
*/
void GPU_basic_shader_use_glsl_set(bool enabled)
{
USE_GLSL = enabled;
}
bool GPU_basic_shader_use_glsl_get(void)
{
return USE_GLSL;
}
/* Init / exit */
void GPU_basic_shaders_init(void)
@ -312,85 +294,16 @@ static void GPU_basic_shader_uniform_autoset(GPUShader *shader, int options)
void GPU_basic_shader_bind(int options)
{
if (USE_GLSL) {
if (options) {
GPUShader *shader = gpu_basic_shader(options);
if (options) {
GPUShader *shader = gpu_basic_shader(options);
if (shader) {
GPU_shader_bind(shader);
GPU_basic_shader_uniform_autoset(shader, options);
}
}
else {
GPU_shader_unbind();
if (shader) {
GPU_shader_bind(shader);
GPU_basic_shader_uniform_autoset(shader, options);
}
}
else {
const int bound_options = GPU_MATERIAL_STATE.bound_options;
if (options & GPU_SHADER_LIGHTING) {
glEnable(GL_LIGHTING);
if (options & GPU_SHADER_USE_COLOR)
glEnable(GL_COLOR_MATERIAL);
else
glDisable(GL_COLOR_MATERIAL);
if (options & GPU_SHADER_TWO_SIDED)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
else
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
}
else if (bound_options & GPU_SHADER_LIGHTING) {
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
}
if (options & GPU_SHADER_TEXTURE_2D) {
GLint env_mode = (options & (GPU_SHADER_USE_COLOR | GPU_SHADER_LIGHTING)) ? GL_MODULATE : GL_REPLACE;
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, env_mode);
}
else if (bound_options & GPU_SHADER_TEXTURE_2D) {
if ((options & GPU_SHADER_TEXTURE_RECT) == 0) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
glDisable(GL_TEXTURE_2D);
}
if (options & GPU_SHADER_TEXTURE_RECT) {
GLint env_mode = (options & (GPU_SHADER_USE_COLOR | GPU_SHADER_LIGHTING)) ? GL_MODULATE : GL_REPLACE;
glEnable(GL_TEXTURE_RECTANGLE);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, env_mode);
}
else if (bound_options & GPU_SHADER_TEXTURE_RECT) {
if ((options & GPU_SHADER_TEXTURE_2D) == 0) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
glDisable(GL_TEXTURE_RECTANGLE);
}
if ((options & GPU_SHADER_LINE) && (options & GPU_SHADER_STIPPLE)) {
glEnable(GL_LINE_STIPPLE);
}
else if ((bound_options & GPU_SHADER_LINE) && (bound_options & GPU_SHADER_STIPPLE)) {
glDisable(GL_LINE_STIPPLE);
}
if (((options & GPU_SHADER_LINE) == 0) && (options & GPU_SHADER_STIPPLE)) {
glEnable(GL_POLYGON_STIPPLE);
}
else if (((bound_options & GPU_SHADER_LINE) == 0) && (bound_options & GPU_SHADER_STIPPLE)) {
glDisable(GL_POLYGON_STIPPLE);
}
if (options & GPU_SHADER_FLAT_NORMAL) {
glShadeModel(GL_FLAT);
}
else if (bound_options & GPU_SHADER_FLAT_NORMAL) {
glShadeModel(GL_SMOOTH);
}
GPU_shader_unbind();
}
GPU_MATERIAL_STATE.bound_options = options;
@ -500,14 +413,12 @@ void GPU_basic_shader_light_set(int light_num, GPULightData *light)
}
else {
/* TODO(sergey): Needs revisit. */
if (USE_GLSL || true) {
/* glsl shader needs these zero to skip them */
const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
/* glsl shader needs these zero to skip them */
const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
glLightfv(GL_LIGHT0 + light_num, GL_POSITION, zero);
glLightfv(GL_LIGHT0 + light_num, GL_DIFFUSE, zero);
glLightfv(GL_LIGHT0 + light_num, GL_SPECULAR, zero);
}
glLightfv(GL_LIGHT0 + light_num, GL_POSITION, zero);
glLightfv(GL_LIGHT0 + light_num, GL_DIFFUSE, zero);
glLightfv(GL_LIGHT0 + light_num, GL_SPECULAR, zero);
glDisable(GL_LIGHT0 + light_num);
}
@ -520,56 +431,19 @@ void GPU_basic_shader_light_set_viewer(bool local)
void GPU_basic_shader_stipple(GPUBasicShaderStipple stipple_id)
{
if (USE_GLSL) {
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_id"), stipple_id);
}
else {
switch (stipple_id) {
case GPU_SHADER_STIPPLE_HALFTONE:
glPolygonStipple(stipple_halftone);
return;
case GPU_SHADER_STIPPLE_QUARTTONE:
glPolygonStipple(stipple_quarttone);
return;
case GPU_SHADER_STIPPLE_CHECKER_8PX:
glPolygonStipple(stipple_checker_8px);
return;
case GPU_SHADER_STIPPLE_HEXAGON:
glPolygonStipple(stipple_hexagon);
return;
case GPU_SHADER_STIPPLE_DIAG_STRIPES_SWAP:
glPolygonStipple(stipple_diag_stripes_neg);
return;
case GPU_SHADER_STIPPLE_DIAG_STRIPES:
glPolygonStipple(stipple_diag_stripes_pos);
return;
default:
glPolygonStipple(stipple_hexagon);
return;
}
}
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_id"), stipple_id);
}
void GPU_basic_shader_line_width(float line_width)
{
if (USE_GLSL) {
GPU_MATERIAL_STATE.line_width = line_width;
if (GPU_MATERIAL_STATE.bound_options & GPU_SHADER_LINE) {
glUniform1f(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "line_width"), line_width);
}
}
else {
glLineWidth(line_width);
GPU_MATERIAL_STATE.line_width = line_width;
if (GPU_MATERIAL_STATE.bound_options & GPU_SHADER_LINE) {
glUniform1f(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "line_width"), line_width);
}
}
void GPU_basic_shader_line_stipple(GLint stipple_factor, GLushort stipple_pattern)
{
if (USE_GLSL) {
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_factor"), stipple_factor);
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_pattern"), stipple_pattern);
}
else {
glLineStipple(stipple_factor, stipple_pattern);
}
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_factor"), stipple_factor);
glUniform1i(GPU_shader_get_uniform(gpu_basic_shader(GPU_MATERIAL_STATE.bound_options), "stipple_pattern"), stipple_pattern);
}

12
source/creator/creator_args.c
View File

@ -1182,16 +1182,6 @@ static int arg_handle_threads_set(int argc, const char **argv, void *UNUSED(data
}
}
static const char arg_handle_basic_shader_use_legacy_doc[] =
"\n\tUse legacy (non-GLSL) basic shader"
;
static int arg_handle_basic_shader_use_legacy(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
{
printf("Using legacy (non-GLSL) basic shader.\n");
GPU_basic_shader_use_glsl_set(false);
return 0;
}
static const char arg_handle_verbosity_set_doc[] =
"<verbose>\n"
"\tSet logging verbosity level."
@ -1829,8 +1819,6 @@ void main_args_setup(bContext *C, bArgs *ba, SYS_SystemHandle *syshandle)
BLI_argsAdd(ba, 1, NULL, "--debug-gpumem",
CB_EX(arg_handle_debug_mode_generic_set, gpumem), (void *)G_DEBUG_GPU_MEM);
BLI_argsAdd(ba, 1, NULL, "--enable-legacy-basic-shader", CB(arg_handle_basic_shader_use_legacy), NULL);
BLI_argsAdd(ba, 1, NULL, "--verbose", CB(arg_handle_verbosity_set), NULL);
BLI_argsAdd(ba, 1, NULL, "--factory-startup", CB(arg_handle_factory_startup_set), NULL);