archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

OpenGL: remove non-GLSL option from basic shader

Browse Source 
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
Download Patch File Download Diff File Expand all files Collapse all files

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);
}