archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
3c48a21833fde41b9dcd3650518af85d44ce91ed
blender-archive/source/blender/gpu/intern/gpu_shader.c

860 lines
35 KiB
C
Raw Normal View History

OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Brecht Van Lommel.
*
* ***** END GPL LICENSE BLOCK *****
*/
#include "MEM_guardedalloc.h"
#include "BLI_utildefines.h"
#include "BLI_math_base.h"
#include "BLI_math_vector.h"
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
#include "BLI_path_util.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
#include "BKE_appdir.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#include "BKE_global.h"
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
#include "DNA_space_types.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#include "GPU_extensions.h"
Merge remote-tracking branch 'origin/master' into blender2.8
2017-04-18 16:30:13 +02:00
#include "GPU_matrix.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#include "GPU_shader.h"
#include "GPU_texture.h"
Merge remote-tracking branch 'origin/master' into blender2.8
2017-04-18 16:30:13 +02:00
#include "GPU_uniformbuffer.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
Blender 2.8: Fix some strict aspects on Linux
2016-09-16 17:18:19 +02:00
#include "gpu_shader_private.h"
shrink fixed-size internal GLSL string buffers We concatenate #defines and #extensions into these, and can count the max string lengths needed. 256 is enough to hold today's strings; we can adjust later if needed.
2017-04-07 13:28:42 -04:00
/* Adjust these constants as needed. */
#define MAX_DEFINE_LENGTH 256
#define MAX_EXT_DEFINE_LENGTH 256
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
/* Non-generated shaders */
OpenGL: add built-in GPU_SHADER_3D_DEPTH_ONLY We’re discussing several techniques that require a depth pre-pass.
2016-09-13 02:51:38 -04:00
extern char datatoc_gpu_shader_depth_only_frag_glsl[];
OpenGL: shaders for simple 3D drawing These are intended for very simple drawing. No lighting etc. Shares some fragment code with the 2D shaders. Similar to their 2D counterparts, but are not combined because of future plans for separate 2D & 3D matrix stacks.
2016-08-16 14:58:53 -04:00
extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_COLORBAND Introduced a new checker shader to be used mostly on transparent areas. OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_UNITVEC Introduced a new shader to be used for simple lighting.
2017-02-07 13:04:08 +01:00
extern char datatoc_gpu_shader_checker_frag_glsl[];
Add diagonal stripe shader (GPU_SHADER_2D_DIAG_STRIPES) Reviewed By: merwin Differential Revision: https://developer.blender.org/D2512
2017-02-16 21:49:20 -02:00
extern char datatoc_gpu_shader_diag_stripes_frag_glsl[];
OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_COLORBAND Introduced a new checker shader to be used mostly on transparent areas. OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_UNITVEC Introduced a new shader to be used for simple lighting.
2017-02-07 13:04:08 +01:00
extern char datatoc_gpu_shader_simple_lighting_frag_glsl[];
DWM: Use Gawain for sculpt drawing Currently only uses the simple shader.
2017-05-10 20:14:52 +10:00
extern char datatoc_gpu_shader_simple_lighting_flat_color_frag_glsl[];
OpenGL: Convert drawobject.c (cont) Particle system (not edit mode)
2017-03-11 16:10:03 +01:00
extern char datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl[];
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
extern char datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl[];
OpenGL: shaders for simple 3D drawing These are intended for very simple drawing. No lighting etc. Shares some fragment code with the 2D shaders. Similar to their 2D counterparts, but are not combined because of future plans for separate 2D & 3D matrix stacks.
2016-08-16 14:58:53 -04:00
extern char datatoc_gpu_shader_flat_color_frag_glsl[];
OpenGL: edge shader discards fragments of unused edges Discarded edges should not update depth buffer or blend with color buffer. Geometry shader version will make this obsolete.
2016-10-26 03:57:14 -04:00
extern char datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl[];
OpenGL: new built-in point shader, clean up other shader names Smooth round point with outline (uniform color) and fill (varying color). Updated shader naming scheme: a shader that doesn't deal with color does not have to say "no color". Vertex shaders do not have to say "uniform color" since their frag counterpart actually has the uniform. Each name should describe what that shader *does*, not what it *doesn't do*.
2016-10-15 02:30:59 -04:00
extern char datatoc_gpu_shader_2D_vert_glsl[];
OpenGL: simple 2D shader with flat color Flat color means each primitive will use color from the provoking vertex.
2016-08-08 04:56:02 -04:00
extern char datatoc_gpu_shader_2D_flat_color_vert_glsl[];
OpenGL: add simple shaders for 2D drawing The first two of several new simple built-in shaders (will test these before adding more). These are intended for the new immediate mode API, but you can use them just like any built-in GPUShader. Due to limitations on different platforms, shaders need to work with GLSL versions 120, 130 and 150. Final Blender 2.8 will be pure #version 150.
2016-08-04 15:59:38 -04:00
extern char datatoc_gpu_shader_2D_smooth_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_frag_glsl[];
convert icon_draw_texture to gawain imm mode replacements
2016-11-18 16:04:25 +01:00
extern char datatoc_gpu_shader_2D_image_vert_glsl[];
UI: Perf: Make icon_draw_texture use GWN_draw_primitive. This bypass the use of immediate mode for theses drawcalls. Placement and and icon select (via uvs) is done inside the vertex shader.
2018-03-27 23:57:29 +02:00
extern char datatoc_gpu_shader_2D_image_rect_vert_glsl[];
convert icon_draw_texture to gawain imm mode replacements
2016-11-18 16:04:25 +01:00
OpenGL: tweak image shaders & code that uses them - rename image shaders to describe exactly what they do - rename inputs to match other built-in shaders - set & use active texture unit - no need to enable/disable textures with GLSL - pull vertex format setup out of loops
2016-10-18 00:08:34 -04:00
extern char datatoc_gpu_shader_3D_image_vert_glsl[];
Code cleanup: stop using rectangle textures in window draw, simplify code.
2018-02-13 18:09:58 +01:00
extern char datatoc_gpu_shader_image_frag_glsl[];
Eevee: Add tonemapping using ocio. Actually it's done by the Draw Manager, so other engines can use it.
2017-05-11 16:20:10 +02:00
extern char datatoc_gpu_shader_image_linear_frag_glsl[];
convert icon_draw_texture to gawain imm mode replacements
2016-11-18 16:04:25 +01:00
extern char datatoc_gpu_shader_image_color_frag_glsl[];
Fix alpha overlay for sculpt/paint when using core profile Same fundamental problem as fonts -- there is no longer GL_ALPHA format.
2017-04-19 16:52:47 +02:00
extern char datatoc_gpu_shader_image_alpha_color_frag_glsl[];
OpenGL immediate mode: new shader image shuffle color new shader to draw an image with one isolated channel
2017-02-24 01:07:40 +01:00
extern char datatoc_gpu_shader_image_shuffle_color_frag_glsl[];
Fix T49861: Interlace stereo drawing This does not address stapling shader in 2.8, though the solution can be similar (own shader, not polutting interlace shader). part of T49043 Reviewers: merwin Differential Revision: https://developer.blender.org/D2440
2017-01-09 17:58:13 +01:00
extern char datatoc_gpu_shader_image_interlace_frag_glsl[];
OpenGL: wm_operators.c uses new immediate mode D2311 by @ianwill This is the radial control that appears when we change the size of a brush in sculpt and vertex and texture painting modes, by pressing "f". Also includes a new built-in shader that can be useful in other places. Part of T49043
2016-11-08 10:51:42 -05:00
extern char datatoc_gpu_shader_image_mask_uniform_color_frag_glsl[];
OpenGL: tweak image shaders & code that uses them - rename image shaders to describe exactly what they do - rename inputs to match other built-in shaders - set & use active texture unit - no need to enable/disable textures with GLSL - pull vertex format setup out of loops
2016-10-18 00:08:34 -04:00
extern char datatoc_gpu_shader_image_modulate_alpha_frag_glsl[];
Viewport: create a shader to show depth images linearized
2016-10-21 20:48:08 +00:00
extern char datatoc_gpu_shader_image_depth_linear_frag_glsl[];
DRW: Add new Draw Manager OpenGL Context. This separate context allows two things: - It allows viewports in multi-windows configuration. - F12 render can use this context in a separate thread and do a non-blocking render. The downside is that the context cannot be used while rendering so a request to refresh a viewport will lock the UI. This is something that will be adressed in the future. Under the hood what does that mean: - Not adding more mess with VAOs management in gawain. - Doing depth only draw for operators / selection needs to be done in an offscreen buffer. - The 3D cursor "autodis" operator is still reading the backbuffer so we need to copy the result to it. - All FBOs needed by the drawmanager must to be created/destroyed with its context active. - We cannot use batches created for UI in the DRW context and vice-versa. There is a clear separation of resources that enables the use of safe multi-threading.
2018-02-26 19:41:17 +01:00
extern char datatoc_gpu_shader_image_depth_copy_frag_glsl[];
OpenGL: new built-in point shader, clean up other shader names Smooth round point with outline (uniform color) and fill (varying color). Updated shader naming scheme: a shader that doesn't deal with color does not have to say "no color". Vertex shaders do not have to say "uniform color" since their frag counterpart actually has the uniform. Each name should describe what that shader *does*, not what it *doesn't do*.
2016-10-15 02:30:59 -04:00
extern char datatoc_gpu_shader_3D_vert_glsl[];
OpenGL: fix GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR The fragment shader expects a normal, but the vertex shader was not providing one. Fix: added a new vertex shader that has normals + smooth color interpolation. I also split gpu_shader_3D_vert in two: - one with just position - one with position + normal For each of the builtin shaders, we should be able to look at the GLSL and tell exactly what it's doing. Using #defines and #ifdefs for rendering options makes the shaders hard to read and easy to break.
2017-04-16 15:04:07 -04:00
extern char datatoc_gpu_shader_3D_normal_vert_glsl[];
OpenGL: shaders for simple 3D drawing These are intended for very simple drawing. No lighting etc. Shares some fragment code with the 2D shaders. Similar to their 2D counterparts, but are not combined because of future plans for separate 2D & 3D matrix stacks.
2016-08-16 14:58:53 -04:00
extern char datatoc_gpu_shader_3D_flat_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_smooth_color_vert_glsl[];
DWM: Use Gawain for sculpt drawing Currently only uses the simple shader.
2017-05-10 20:14:52 +10:00
extern char datatoc_gpu_shader_3D_normal_flat_color_vert_glsl[];
OpenGL: fix GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR The fragment shader expects a normal, but the vertex shader was not providing one. Fix: added a new vertex shader that has normals + smooth color interpolation. I also split gpu_shader_3D_vert in two: - one with just position - one with position + normal For each of the builtin shaders, we should be able to look at the GLSL and tell exactly what it's doing. Using #defines and #ifdefs for rendering options makes the shaders hard to read and easy to break.
2017-04-16 15:04:07 -04:00
extern char datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl[];
OpenGL: shaders for simple 3D drawing These are intended for very simple drawing. No lighting etc. Shares some fragment code with the 2D shaders. Similar to their 2D counterparts, but are not combined because of future plans for separate 2D & 3D matrix stacks.
2016-08-16 14:58:53 -04:00
extern char datatoc_gpu_shader_3D_smooth_color_frag_glsl[];
GPU shaders / Clay engine : small renaming / cleanup
2017-02-11 21:15:46 +01:00
extern char datatoc_gpu_shader_3D_passthrough_vert_glsl[];
Fix rotation manipulators not clipping Added new shader for clipping, also cleaned up rotation manipulator drawing code a bit. This code should be replaced by new transform manipulators soon, just keeping this working in the meanwhile.
2017-04-05 01:28:48 +02:00
extern char datatoc_gpu_shader_3D_clipped_uniform_color_vert_glsl[];
OpenGL: add simple shaders for 2D drawing The first two of several new simple built-in shaders (will test these before adding more). These are intended for the new immediate mode API, but you can use them just like any built-in GPUShader. Due to limitations on different platforms, shaders need to work with GLSL versions 120, 130 and 150. Final Blender 2.8 will be pure #version 150.
2016-08-04 15:59:38 -04:00
Clay Engine: converted Empties to the new instancing method
2017-02-09 20:55:31 +01:00
extern char datatoc_gpu_shader_instance_vert_glsl[];
extern char datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl[];
Clay Engine: Prepare for Armature drawing. - Added runtime display matrices to EditBone and bPoseChannel - Added Object space instance vertex shader and modified the simple lighting shader accordingly
2017-02-22 12:46:27 +01:00
extern char datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl[];
GPU shaders / Clay engine : small renaming / cleanup
2017-02-11 21:15:46 +01:00
extern char datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl[];
Object Engine: Ported Force Field object drawing.
2017-04-10 22:22:37 +02:00
extern char datatoc_gpu_shader_instance_screen_aligned_vert_glsl[];
Clay Engine: camera drawing
2017-03-04 00:09:22 +01:00
extern char datatoc_gpu_shader_instance_camera_vert_glsl[];
extern char datatoc_gpu_shader_instance_distance_line_vert_glsl[];
Clay Engine: More Lamp drawing work
2017-03-05 05:22:40 +01:00
extern char datatoc_gpu_shader_instance_edges_variying_color_geom_glsl[];
extern char datatoc_gpu_shader_instance_edges_variying_color_vert_glsl[];
DwM: Armature: add solid envelope bone drawing. Envelope bones are now pretty much identical to old drawing code. Note that currently new DwM drawing code does not seem to care about wire/solid drawing modes at all, guess this is still TODO... For now we hence just get both wire and solid for envelope bones, this can be refined later.
2017-05-18 11:41:59 +02:00
extern char datatoc_gpu_shader_instance_bone_envelope_solid_vert_glsl[];
DwM: Armature: Cleanup envelope bone code a bit. Mainly adding 'wire' suffix to wire/distance drawing func and shader. Also, match wire vertex shader behavior with solid one regarding head/tail only drawing (i.e. alwas expect head bone mat, never tail one, and assume that if a radius is negative, then we only draw on the other end of the bone).
2017-05-18 12:10:10 +02:00
extern char datatoc_gpu_shader_instance_bone_envelope_wire_vert_glsl[];
Metalball drawing: rename mball helpers to handles and also rename some related functions
2018-02-16 02:01:09 -02:00
extern char datatoc_gpu_shader_instance_mball_handles_vert_glsl[];
Clay Engine: converted Empties to the new instancing method
2017-02-09 20:55:31 +01:00
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
extern char datatoc_gpu_shader_3D_groundpoint_vert_glsl[];
extern char datatoc_gpu_shader_3D_groundline_geom_glsl[];
OpenGL: new built-in shaders for drawing points Both of these draw round points with jaggy edges, but treat color & size differently.
2016-09-30 20:44:22 -04:00
extern char datatoc_gpu_shader_point_uniform_color_frag_glsl[];
rename built-in point shaders, SMOOTH --> AA Updated shader names and code that uses them. All of these shaders produce round points that are anti-aliased and blended against the background. These were initially named SMOOTH because they replace glEnable(GL_POINT_SMOOTH). But SMOOTH in shader-land refers to vertex attribute interpolation (like glShadeModel(GL_SMOOTH)). Using SMOOTH to mean two things is confusing, so we now use AA to mean "the point is anti-aliased".
2017-02-28 02:18:52 -05:00
extern char datatoc_gpu_shader_point_uniform_color_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_varying_color_outline_aa_frag_glsl[];
OpenGL: new built-in shaders for drawing points Both of these draw round points with jaggy edges, but treat color & size differently.
2016-09-30 20:44:22 -04:00
extern char datatoc_gpu_shader_point_varying_color_frag_glsl[];
extern char datatoc_gpu_shader_3D_point_fixed_size_varying_color_vert_glsl[];
OpenGL: new built-in point shader, clean up other shader names Smooth round point with outline (uniform color) and fill (varying color). Updated shader naming scheme: a shader that doesn't deal with color does not have to say "no color". Vertex shaders do not have to say "uniform color" since their frag counterpart actually has the uniform. Each name should describe what that shader *does*, not what it *doesn't do*.
2016-10-15 02:30:59 -04:00
extern char datatoc_gpu_shader_3D_point_varying_size_vert_glsl[];
OpenGL: one more point shader Added a built-in shader for points that vary both size and color.
2016-10-01 17:32:29 -04:00
extern char datatoc_gpu_shader_3D_point_varying_size_varying_color_vert_glsl[];
rename built-in point shaders, SMOOTH --> AA Updated shader names and code that uses them. All of these shaders produce round points that are anti-aliased and blended against the background. These were initially named SMOOTH because they replace glEnable(GL_POINT_SMOOTH). But SMOOTH in shader-land refers to vertex attribute interpolation (like glShadeModel(GL_SMOOTH)). Using SMOOTH to mean two things is confusing, so we now use AA to mean "the point is anti-aliased".
2017-02-28 02:18:52 -05:00
extern char datatoc_gpu_shader_3D_point_uniform_size_aa_vert_glsl[];
extern char datatoc_gpu_shader_3D_point_uniform_size_outline_aa_vert_glsl[];
OpenGL: another built-in shader for 2D points GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR
2016-10-06 16:31:49 -04:00
extern char datatoc_gpu_shader_2D_point_varying_size_varying_color_vert_glsl[];
rename built-in point shaders, SMOOTH --> AA Updated shader names and code that uses them. All of these shaders produce round points that are anti-aliased and blended against the background. These were initially named SMOOTH because they replace glEnable(GL_POINT_SMOOTH). But SMOOTH in shader-land refers to vertex attribute interpolation (like glShadeModel(GL_SMOOTH)). Using SMOOTH to mean two things is confusing, so we now use AA to mean "the point is anti-aliased".
2017-02-28 02:18:52 -05:00
extern char datatoc_gpu_shader_2D_point_uniform_size_aa_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_uniform_size_outline_aa_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert_glsl[];
OpenGL: new built-in shaders for drawing points Both of these draw round points with jaggy edges, but treat color & size differently.
2016-09-30 20:44:22 -04:00
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
extern char datatoc_gpu_shader_2D_line_dashed_uniform_color_vert_glsl[];
OpenGL: wm_gesture uses new imm mode D2376 by @ianwill, part of T49043 review by @merwin Box select, circle select, etc. Introducing the dashed-line shader! See D2376 for more info.
2017-02-24 15:33:09 -05:00
extern char datatoc_gpu_shader_2D_line_dashed_frag_glsl[];
Reworked version of dashed line shader. Using geometry shader allows us to get rid of the 'line origin' extra vertex attribute, which means dashed shader no longer requires fiddling with those vertex attributes definition, and, most importantly, does not require anymore special drawing code! As you can see, this makes code much simpler, and much less verbose, especially in complex cases. In addition, changed how dashes are handled, to have two 'modes', a simple one with single color (using default "color" uniform name), and a more advanced one allowing more complex and multi-color patterns. Note that since GLSL 1.2 does not support geometry shaders, a hack was added for now (which gives solid lines, but at least does not make Blender crash).
2017-05-01 16:21:53 +02:00
extern char datatoc_gpu_shader_2D_line_dashed_geom_glsl[];
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
extern char datatoc_gpu_shader_3D_line_dashed_uniform_color_legacy_vert_glsl[];
extern char datatoc_gpu_shader_3D_line_dashed_uniform_color_vert_glsl[];
OpenGL: wm_gesture uses new imm mode D2376 by @ianwill, part of T49043 review by @merwin Box select, circle select, etc. Introducing the dashed-line shader! See D2376 for more info.
2017-02-24 15:33:09 -05:00
OpenGL: new built-in shaders for mesh edges
2016-10-25 03:19:10 -04:00
extern char datatoc_gpu_shader_edges_front_back_persp_vert_glsl[];
OpenGL: further wireframe shaders As seen at #bcon16 Geometry shader version is automatically used on modern GL runtimes. Legacy version is used on pre-3.2 systems (Mac, Mesa compat profile). They have the same inputs and visual result. TODO: specialized versions that are less flexible -- draw ALL edges or draw JUST silhouette edges. Part of T49165
2016-11-05 18:56:57 +01:00
extern char datatoc_gpu_shader_edges_front_back_persp_geom_glsl[];
extern char datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl[];
OpenGL: new built-in shaders for mesh edges
2016-10-25 03:19:10 -04:00
extern char datatoc_gpu_shader_edges_front_back_ortho_vert_glsl[];
OpenGL: edge overlay shaders As seen at #bcon16. These were produced quickly and probably need further work. SIMPLE variant draws triangle mesh edges. Based on this research: http://www2.imm.dtu.dk/pubdb/views/edoc_download.php/4884/pdf/imm4884.pdf http://developer.download.nvidia.com/SDK/10/direct3d/Source/SolidWireframe/Doc/SolidWireframe.pdf Non-SIMPLE variant can adjust thickness per edge. This can be used to draw only some edges, or accentuate some edges. Given the right inputs this is a general n-gon perimeter shader. Part of T49165
2016-11-05 19:26:13 +01:00
extern char datatoc_gpu_shader_edges_overlay_vert_glsl[];
extern char datatoc_gpu_shader_edges_overlay_geom_glsl[];
extern char datatoc_gpu_shader_edges_overlay_simple_geom_glsl[];
extern char datatoc_gpu_shader_edges_overlay_frag_glsl[];
add GPU_SHADER_TEXT for font rendering With USE_GLSL enabled, GPU_basic_shader(TEXTURE|COLOR) always rendered black. New shader uses a solid color + alpha channel of texture (which in our case is a font glyph). See fragment shader for details. I prefer this approah -- multiple shaders that each do one thing well (and are easy to read/write/understand), instead of one shader that can do many things given the right options.
2016-09-17 13:33:02 +02:00
extern char datatoc_gpu_shader_text_vert_glsl[];
extern char datatoc_gpu_shader_text_frag_glsl[];
add builtin GPU_SHADER_KEYFRAME_DIAMOND Now we can draw keyframe markers as point sprites, with fewer draw calls and state changes. Based on the builtin shader for round points with anti-aliased outline. This one is more pointy.
2017-02-11 00:02:28 -05:00
extern char datatoc_gpu_shader_keyframe_diamond_vert_glsl[];
extern char datatoc_gpu_shader_keyframe_diamond_frag_glsl[];
add GPU_SHADER_TEXT for font rendering With USE_GLSL enabled, GPU_basic_shader(TEXTURE|COLOR) always rendered black. New shader uses a solid color + alpha channel of texture (which in our case is a font glyph). See fragment shader for details. I prefer this approah -- multiple shaders that each do one thing well (and are easy to read/write/understand), instead of one shader that can do many things given the right options.
2016-09-17 13:33:02 +02:00
Fix T47639: OpenGL render with smoke and fire incorrect when using transparency. The issue is that we are rendering to a 0..1 clamped sRGB buffer with unpremultiplied alpha, where the correct thing to do would be to render to an unclamped linear premultiplied alpha buffer. Then we would just make fire purely emissive without affecting the alpha channel at all, but that doesn't work here. So for now, draw fire and smoke separately using different shaders and blend modes, like it used to before the smoke programs were rewritten (see rB0372b642).
2016-08-28 16:50:49 +02:00
extern char datatoc_gpu_shader_fire_frag_glsl[];
OpenGL: port smoke drawing code to GLSL. Beside the obvious ARB -> GLSL change, the texture slicing algorithm had to be rewritten. Although this new algorithm has the same behaviour as the old one (view aligned slicing), it works with an arbitrary number of slices (which could eventually be set by the user), which means we can preallocate the buffer. The previous algorithm would slice from the begining to the end of the volume's bbox, and draw the slices as it generates them. Also support for ARB program was removed. Patch by myself, with some minor fixes by Brecht. Reviewers: brecht, #opengl_gfx Differential Revision: https://developer.blender.org/D1694
2016-01-10 07:36:23 +01:00
extern char datatoc_gpu_shader_smoke_vert_glsl[];
extern char datatoc_gpu_shader_smoke_frag_glsl[];
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
extern char datatoc_gpu_shader_vsm_store_vert_glsl[];
extern char datatoc_gpu_shader_vsm_store_frag_glsl[];
extern char datatoc_gpu_shader_sep_gaussian_blur_vert_glsl[];
extern char datatoc_gpu_shader_sep_gaussian_blur_frag_glsl[];
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
/* cache of built-in shaders (each is created on first use) */
static GPUShader *builtin_shaders[GPU_NUM_BUILTIN_SHADERS] = { NULL };
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
typedef struct {
const char *vert;
const char *frag;
const char *geom; /* geometry stage runs between vert & frag, but is less common, so it goes last */
} GPUShaderStages;
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
static void shader_print_errors(const char *task, const char *log, const char **code, int totcode)
{
int line = 1;
fprintf(stderr, "GPUShader: %s error:\n", task);
OpenGL: add GLSL #version 330, drop 140 and 150 GL 3.3 is the new minimum. Compatibility profile for now, core profile eventually. During development, GL 3.0 (on Mesa) and 2.1 (on Mac) will still work. Part of T49012
2016-10-16 03:18:17 -04:00
for (int i = 0; i < totcode; i++) {
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
const char *c, *pos, *end = code[i] + strlen(code[i]);
if (G.debug & G_DEBUG) {
fprintf(stderr, "===== shader string %d ====\n", i + 1);
c = code[i];
while ((c < end) && (pos = strchr(c, '\n'))) {
fprintf(stderr, "%2d ", line);
fwrite(c, (pos + 1) - c, 1, stderr);
c = pos + 1;
line++;
}
fprintf(stderr, "%s", c);
}
}
fprintf(stderr, "%s\n", log);
}
static const char *gpu_shader_version(void)
{
OpenGL: support GLSL 3.3 core profile When WITH_LEGACY_OPENGL = OFF. This is our final target for Blender 2.8, all previous versions will be dropped in the future. GLSL 3.3 is richer so we don't require as many extensions.
2017-04-07 12:50:44 -04:00
return "#version 330\n";
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
OpenGL: drop support for EXT_geometry_shader4 See gpu_shader.c for the main changes. EXT_geometry_shader4 brought this feature to GL versions < 3.2, but now it's just cluttering up our code. Soon all platforms will be on version 3.3 so we won't even have to check support at runtime!
2017-04-08 02:21:13 -04:00
static void gpu_shader_standard_extensions(char defines[MAX_EXT_DEFINE_LENGTH])
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
/* enable extensions for features that are not part of our base GLSL version
* don't use an extension for something already available!
*/
if (GLEW_ARB_texture_query_lod) {
GPU: cleanup GLSL version and standard extensions Now we always use GLSL 3.3, AKA #version 330. Most of the extensions we used are built into OpenGL 3.3 so we don't need them anymore. Cleaned up comments related to GLSL version. Part of T49012
2017-05-18 15:47:32 -04:00
/* a #version 400 feature, but we use #version 330 maximum so use extension */
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
strcat(defines, "#extension GL_ARB_texture_query_lod: enable\n");
}
}
Fix T47207: Material shading incorrectly handles colorramp node The issue was introduced by a fix for T44713 which only made GLSL consistent with Cycles. Now we do have conditional averaging or proper luma weighting based on whether we're new old old shading system. Not totally ideal but should work for until we re-design viewport possibly breaking how Blender Internal does implicit conversion.
2016-02-02 12:48:18 +01:00
static void gpu_shader_standard_defines(char defines[MAX_DEFINE_LENGTH],
bool use_opensubdiv,
bool use_new_shading)
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
/* some useful defines to detect GPU type */
if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY)) {
strcat(defines, "#define GPU_ATI\n");
if (GLEW_VERSION_3_0) {
/* TODO(merwin): revisit this version check; GLEW_VERSION_3_0 means GL 3.0 or newer */
strcat(defines, "#define CLIP_WORKAROUND\n");
}
}
else if (GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY))
strcat(defines, "#define GPU_NVIDIA\n");
else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_ANY, GPU_DRIVER_ANY))
strcat(defines, "#define GPU_INTEL\n");
if (GPU_bicubic_bump_support())
strcat(defines, "#define BUMP_BICUBIC\n");
#ifdef WITH_OPENSUBDIV
/* TODO(sergey): Check whether we actually compiling shader for
* the OpenSubdiv mesh.
*/
if (use_opensubdiv) {
strcat(defines, "#define USE_OPENSUBDIV\n");
/* TODO(sergey): not strictly speaking a define, but this is
* a global typedef which we don't have better place to define
* in yet.
*/
strcat(defines, "struct VertexData {\n"
" vec4 position;\n"
" vec3 normal;\n"
" vec2 uv;"
"};\n");
}
#else
UNUSED_VARS(use_opensubdiv);
#endif
Fix T47207: Material shading incorrectly handles colorramp node The issue was introduced by a fix for T44713 which only made GLSL consistent with Cycles. Now we do have conditional averaging or proper luma weighting based on whether we're new old old shading system. Not totally ideal but should work for until we re-design viewport possibly breaking how Blender Internal does implicit conversion.
2016-02-02 12:48:18 +01:00
if (use_new_shading) {
strcat(defines, "#define USE_NEW_SHADING\n");
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
return;
}
GPUShader *GPU_shader_create(const char *vertexcode,
const char *fragcode,
const char *geocode,
const char *libcode,
OpenGL: drop support for EXT_geometry_shader4 See gpu_shader.c for the main changes. EXT_geometry_shader4 brought this feature to GL versions < 3.2, but now it's just cluttering up our code. Soon all platforms will be on version 3.3 so we won't even have to check support at runtime!
2017-04-08 02:21:13 -04:00
const char *defines)
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
return GPU_shader_create_ex(vertexcode,
fragcode,
geocode,
libcode,
defines,
GPU_SHADER_FLAGS_NONE);
}
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
#define DEBUG_SHADER_NONE ""
#define DEBUG_SHADER_VERTEX "vert"
#define DEBUG_SHADER_FRAGMENT "frag"
#define DEBUG_SHADER_GEOMETRY "geom"
/**
* Dump GLSL shaders to disk
*
* This is used for profiling shader performance externally and debug if shader code is correct.
* If called with no code, it simply bumps the shader index, so different shaders for the same
* program share the same index.
*/
static void gpu_dump_shaders(const char **code, const int num_shaders, const char *extension)
{
if ((G.debug & G_DEBUG_GPU_SHADERS) == 0) {
return;
}
/* We use the same shader index for shaders in the same program.
* So we call this function once before calling for the invidual shaders. */
static int shader_index = 0;
if (code == NULL) {
shader_index++;
BLI_assert(STREQ(DEBUG_SHADER_NONE, extension));
return;
}
/* Determine the full path of the new shader. */
char shader_path[FILE_MAX];
char file_name[512] = {'\0'};
sprintf(file_name, "%04d.%s", shader_index, extension);
BLI_join_dirfile(shader_path, sizeof(shader_path), BKE_tempdir_session(), file_name);
/* Write shader to disk. */
FILE *f = fopen(shader_path, "w");
if (f == NULL) {
printf("Error writing to file: %s\n", shader_path);
}
for (int j = 0; j < num_shaders; j++) {
fprintf(f, "%s", code[j]);
}
fclose(f);
printf("Shader file written to disk: %s\n", shader_path);
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
GPUShader *GPU_shader_create_ex(const char *vertexcode,
const char *fragcode,
const char *geocode,
const char *libcode,
const char *defines,
const int flags)
{
#ifdef WITH_OPENSUBDIV
bool use_opensubdiv = (flags & GPU_SHADER_FLAGS_SPECIAL_OPENSUBDIV) != 0;
#else
UNUSED_VARS(flags);
bool use_opensubdiv = false;
#endif
GLint status;
GLchar log[5000];
GLsizei length = 0;
GPUShader *shader;
char standard_defines[MAX_DEFINE_LENGTH] = "";
char standard_extensions[MAX_EXT_DEFINE_LENGTH] = "";
shader = MEM_callocN(sizeof(GPUShader), "GPUShader");
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
gpu_dump_shaders(NULL, 0, DEBUG_SHADER_NONE);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
if (vertexcode)
shader->vertex = glCreateShader(GL_VERTEX_SHADER);
if (fragcode)
shader->fragment = glCreateShader(GL_FRAGMENT_SHADER);
if (geocode)
shader->geometry = glCreateShader(GL_GEOMETRY_SHADER_EXT);
shader->program = glCreateProgram();
if (!shader->program ||
(vertexcode && !shader->vertex) ||
(fragcode && !shader->fragment) ||
(geocode && !shader->geometry))
{
fprintf(stderr, "GPUShader, object creation failed.\n");
GPU_shader_free(shader);
return NULL;
}
Fix T47207: Material shading incorrectly handles colorramp node The issue was introduced by a fix for T44713 which only made GLSL consistent with Cycles. Now we do have conditional averaging or proper luma weighting based on whether we're new old old shading system. Not totally ideal but should work for until we re-design viewport possibly breaking how Blender Internal does implicit conversion.
2016-02-02 12:48:18 +01:00
gpu_shader_standard_defines(standard_defines,
use_opensubdiv,
(flags & GPU_SHADER_FLAGS_NEW_SHADING) != 0);
OpenGL: drop support for EXT_geometry_shader4 See gpu_shader.c for the main changes. EXT_geometry_shader4 brought this feature to GL versions < 3.2, but now it's just cluttering up our code. Soon all platforms will be on version 3.3 so we won't even have to check support at runtime!
2017-04-08 02:21:13 -04:00
gpu_shader_standard_extensions(standard_extensions);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
if (vertexcode) {
const char *source[5];
/* custom limit, may be too small, beware */
int num_source = 0;
source[num_source++] = gpu_shader_version();
source[num_source++] = standard_extensions;
source[num_source++] = standard_defines;
if (defines) source[num_source++] = defines;
source[num_source++] = vertexcode;
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
gpu_dump_shaders(source, num_source, DEBUG_SHADER_VERTEX);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
glAttachShader(shader->program, shader->vertex);
glShaderSource(shader->vertex, num_source, source, NULL);
glCompileShader(shader->vertex);
glGetShaderiv(shader->vertex, GL_COMPILE_STATUS, &status);
if (!status) {
glGetShaderInfoLog(shader->vertex, sizeof(log), &length, log);
shader_print_errors("compile", log, source, num_source);
GPU_shader_free(shader);
return NULL;
}
}
if (fragcode) {
const char *source[7];
int num_source = 0;
source[num_source++] = gpu_shader_version();
source[num_source++] = standard_extensions;
source[num_source++] = standard_defines;
#ifdef WITH_OPENSUBDIV
/* TODO(sergey): Move to fragment shader source code generation. */
if (use_opensubdiv) {
source[num_source++] =
"#ifdef USE_OPENSUBDIV\n"
"in block {\n"
" VertexData v;\n"
"} inpt;\n"
"#endif\n";
}
#endif
if (defines) source[num_source++] = defines;
if (libcode) source[num_source++] = libcode;
source[num_source++] = fragcode;
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
gpu_dump_shaders(source, num_source, DEBUG_SHADER_FRAGMENT);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
glAttachShader(shader->program, shader->fragment);
glShaderSource(shader->fragment, num_source, source, NULL);
glCompileShader(shader->fragment);
glGetShaderiv(shader->fragment, GL_COMPILE_STATUS, &status);
if (!status) {
glGetShaderInfoLog(shader->fragment, sizeof(log), &length, log);
shader_print_errors("compile", log, source, num_source);
GPU_shader_free(shader);
return NULL;
}
}
if (geocode) {
const char *source[6];
int num_source = 0;
source[num_source++] = gpu_shader_version();
source[num_source++] = standard_extensions;
source[num_source++] = standard_defines;
if (defines) source[num_source++] = defines;
source[num_source++] = geocode;
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
gpu_dump_shaders(source, num_source, DEBUG_SHADER_GEOMETRY);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
glAttachShader(shader->program, shader->geometry);
glShaderSource(shader->geometry, num_source, source, NULL);
glCompileShader(shader->geometry);
glGetShaderiv(shader->geometry, GL_COMPILE_STATUS, &status);
if (!status) {
glGetShaderInfoLog(shader->geometry, sizeof(log), &length, log);
shader_print_errors("compile", log, source, num_source);
GPU_shader_free(shader);
return NULL;
}
}
#ifdef WITH_OPENSUBDIV
if (use_opensubdiv) {
glBindAttribLocation(shader->program, 0, "position");
glBindAttribLocation(shader->program, 1, "normal");
}
#endif
glLinkProgram(shader->program);
glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
if (!status) {
glGetProgramInfoLog(shader->program, sizeof(log), &length, log);
/* print attached shaders in pipeline order */
if (vertexcode) shader_print_errors("linking", log, &vertexcode, 1);
if (geocode) shader_print_errors("linking", log, &geocode, 1);
if (libcode) shader_print_errors("linking", log, &libcode, 1);
if (fragcode) shader_print_errors("linking", log, &fragcode, 1);
GPU_shader_free(shader);
return NULL;
}
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
shader->interface = GWN_shaderinterface_create(shader->program);
OpenGL: use ShaderInterface to look up uniforms These were the last few glGetUniformLocation calls in source/blender. The new system gets uniform information once when a shader is created, then uses this cached info every time after that.
2017-04-13 18:37:26 -04:00
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#ifdef WITH_OPENSUBDIV
/* TODO(sergey): Find a better place for this. */
OpenGL: call glProgramUniform only if version >= 4.1 Otherwise crash! Called from OpenSubdiv setup code. Might start using this in more places...
2017-05-18 18:30:09 -04:00
if (use_opensubdiv) {
if (GLEW_VERSION_4_1) {
glProgramUniform1i(shader->program,
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN_shaderinterface_uniform(shader->interface, "FVarDataOffsetBuffer")->location,
OpenGL: call glProgramUniform only if version >= 4.1 Otherwise crash! Called from OpenSubdiv setup code. Might start using this in more places...
2017-05-18 18:30:09 -04:00
30); /* GL_TEXTURE30 */
glProgramUniform1i(shader->program,
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN_shaderinterface_uniform(shader->interface, "FVarDataBuffer")->location,
OpenGL: call glProgramUniform only if version >= 4.1 Otherwise crash! Called from OpenSubdiv setup code. Might start using this in more places...
2017-05-18 18:30:09 -04:00
31); /* GL_TEXTURE31 */
}
else {
glUseProgram(shader->program);
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
glUniform1i(GWN_shaderinterface_uniform(shader->interface, "FVarDataOffsetBuffer")->location, 30);
glUniform1i(GWN_shaderinterface_uniform(shader->interface, "FVarDataBuffer")->location, 31);
OpenGL: call glProgramUniform only if version >= 4.1 Otherwise crash! Called from OpenSubdiv setup code. Might start using this in more places...
2017-05-18 18:30:09 -04:00
glUseProgram(0);
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
#endif
return shader;
}
--debug-gpu-shader: Dump GLSL shaders to disk This is really convenient for development. Either for profiling the generated shaders or to check if the generated code is correct. It writes the shaders to the temporary blender session folder.
2017-09-27 18:03:00 +02:00
#undef DEBUG_SHADER_GEOMETRY
#undef DEBUG_SHADER_FRAGMENT
#undef DEBUG_SHADER_VERTEX
#undef DEBUG_SHADER_NONE
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
void GPU_shader_bind(GPUShader *shader)
{
safety checks in GPU shader library If shader compilation fails, or for some other reason the shader is NULL or 0, we need to know.
2016-09-27 19:38:35 +02:00
BLI_assert(shader && shader->program);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
glUseProgram(shader->program);
Gawain: use ShaderInterface to manage uniforms This eliminates tons of glGetUniformLocation calls from the drawing loop. Vast majority of code can keep making the same function calls. They're just faster now! - Batch_Uniform* - immUniform* - gpuBindMatrices - and others
2017-04-12 18:55:32 -04:00
gpuBindMatrices(shader->interface);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
void GPU_shader_unbind(void)
{
glUseProgram(0);
}
void GPU_shader_free(GPUShader *shader)
{
safety checks in GPU shader library If shader compilation fails, or for some other reason the shader is NULL or 0, we need to know.
2016-09-27 19:38:35 +02:00
BLI_assert(shader);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
if (shader->vertex)
glDeleteShader(shader->vertex);
if (shader->geometry)
glDeleteShader(shader->geometry);
if (shader->fragment)
glDeleteShader(shader->fragment);
if (shader->program)
glDeleteProgram(shader->program);
GPU compositing: Minor optimization: Store the uniform interface of shaders instead of re-querying every frame.
2016-03-21 00:53:48 +01:00
plug ShaderInterface into GPUShader Renamed existing getter/setter that only FX shaders use. We could convert FX code to use the richer new interface or leave it as is. Removed unused GPUShader fields. ShaderInterface tracks the same information.
2017-03-02 21:46:54 -05:00
if (shader->interface)
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
GWN_shaderinterface_discard(shader->interface);
plug ShaderInterface into GPUShader Renamed existing getter/setter that only FX shaders use. We could convert FX code to use the richer new interface or leave it as is. Removed unused GPUShader fields. ShaderInterface tracks the same information.
2017-03-02 21:46:54 -05:00
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
MEM_freeN(shader);
}
int GPU_shader_get_uniform(GPUShader *shader, const char *name)
{
safety checks in GPU shader library If shader compilation fails, or for some other reason the shader is NULL or 0, we need to know.
2016-09-27 19:38:35 +02:00
BLI_assert(shader && shader->program);
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
const Gwn_ShaderInput *uniform = GWN_shaderinterface_uniform(shader->interface, name);
OpenGL: use ShaderInterface to look up uniforms These were the last few glGetUniformLocation calls in source/blender. The new system gets uniform information once when a shader is created, then uses this cached info every time after that.
2017-04-13 18:37:26 -04:00
return uniform ? uniform->location : -1;
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
Gawain: Make common uniforms become builtins This improves eevee's cache performance by 13% in my test.
2017-10-08 15:49:25 +02:00
int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin)
{
BLI_assert(shader && shader->program);
const Gwn_ShaderInput *uniform = GWN_shaderinterface_uniform_builtin(shader->interface, builtin);
return uniform ? uniform->location : -1;
}
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
int GPU_shader_get_uniform_block(GPUShader *shader, const char *name)
{
BLI_assert(shader && shader->program);
Gawain: Add UBOs to shader interface.
2017-10-06 14:57:21 +02:00
const Gwn_ShaderInput *ubo = GWN_shaderinterface_ubo(shader->interface, name);
return ubo ? ubo->location : -1;
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
}
plug ShaderInterface into GPUShader Renamed existing getter/setter that only FX shaders use. We could convert FX code to use the richer new interface or leave it as is. Removed unused GPUShader fields. ShaderInterface tracks the same information.
2017-03-02 21:46:54 -05:00
void *GPU_shader_get_interface(GPUShader *shader)
{
return shader->interface;
}
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
/* Clement : Temp */
int GPU_shader_get_program(GPUShader *shader)
{
return (int)shader->program;
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int length, int arraysize, const float *value)
{
if (location == -1 || value == NULL)
return;
if (length == 1) glUniform1fv(location, arraysize, value);
else if (length == 2) glUniform2fv(location, arraysize, value);
else if (length == 3) glUniform3fv(location, arraysize, value);
else if (length == 4) glUniform4fv(location, arraysize, value);
else if (length == 9) glUniformMatrix3fv(location, arraysize, 0, value);
else if (length == 16) glUniformMatrix4fv(location, arraysize, 0, value);
}
void GPU_shader_uniform_vector_int(GPUShader *UNUSED(shader), int location, int length, int arraysize, const int *value)
{
if (location == -1)
return;
if (length == 1) glUniform1iv(location, arraysize, value);
else if (length == 2) glUniform2iv(location, arraysize, value);
else if (length == 3) glUniform3iv(location, arraysize, value);
else if (length == 4) glUniform4iv(location, arraysize, value);
}
void GPU_shader_uniform_int(GPUShader *UNUSED(shader), int location, int value)
{
if (location == -1)
return;
OpenGL: don't poll for errors, rely on KHR_debug Errors are caught & reported by our GL debug callback. This gives us way more useful information than sporadic calls to glGetError. I removed almost all use of glGetError, including our own GPU_ASSERT_NO_GL_ERRORS and GPU_CHECK_ERRORS_AROUND macros. Still used in rna_Image_gl_load because it passes unvalidated input to OpenGL functions. Still used in gpu_state_print_fl_ex as an exception handling hack -- will rewrite this soon. The optimism embodied by this commit will not prevent OpenGL errors. We need to analyze what would cause GL to fail at certain points and proactively intercept these failures. Or guarantee they can't happen.
2016-08-19 00:52:52 -04:00
glUniform1i(location, value);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
void GPU_shader_uniform_buffer(GPUShader *shader, int location, GPUUniformBuffer *ubo)
{
int bindpoint = GPU_uniformbuffer_bindpoint(ubo);
if (location == -1) {
return;
}
glUniformBlockBinding(shader->program, location, bindpoint);
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUTexture *tex)
{
int number = GPU_texture_bound_number(tex);
GPUCompositing: Remove entire module. This module has no use now with the new DrawManager and DrawEngines and it is using deprecated paths. Moving gpu_shader_fullscreen_vert.glsl to draw/modes/shaders/common_fullscreen_vert.glsl
2018-03-22 16:10:54 +01:00
if (number == -1) {
fprintf(stderr, "Texture is not bound.\n");
BLI_assert(0);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
return;
}
if (location == -1)
return;
glUniform1i(location, number);
}
int GPU_shader_get_attribute(GPUShader *shader, const char *name)
{
safety checks in GPU shader library If shader compilation fails, or for some other reason the shader is NULL or 0, we need to know.
2016-09-27 19:38:35 +02:00
BLI_assert(shader && shader->program);
Gawain API naming refactor Use consistent prefix for gawain API names as well as some abbreviations to avoid over-long names, see: D2678
2017-06-19 20:18:04 +10:00
const Gwn_ShaderInput *attrib = GWN_shaderinterface_attr(shader->interface, name);
Gawain: use ShaderInterface to manage vertex attribs This eliminates tons of glGetAttribLocation calls from the drawing loop. Vast majority of code can keep making the same function calls. They're just faster now!
2017-04-15 18:06:54 -04:00
return attrib ? attrib->location : -1;
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
{
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
BLI_assert(shader != GPU_NUM_BUILTIN_SHADERS); /* don't be a troll */
static const GPUShaderStages builtin_shader_stages[GPU_NUM_BUILTIN_SHADERS] = {
[GPU_SHADER_VSM_STORE] = { datatoc_gpu_shader_vsm_store_vert_glsl, datatoc_gpu_shader_vsm_store_frag_glsl },
[GPU_SHADER_SEP_GAUSSIAN_BLUR] = { datatoc_gpu_shader_sep_gaussian_blur_vert_glsl,
datatoc_gpu_shader_sep_gaussian_blur_frag_glsl },
[GPU_SHADER_SMOKE] = { datatoc_gpu_shader_smoke_vert_glsl, datatoc_gpu_shader_smoke_frag_glsl },
[GPU_SHADER_SMOKE_FIRE] = { datatoc_gpu_shader_smoke_vert_glsl, datatoc_gpu_shader_smoke_frag_glsl },
[GPU_SHADER_SMOKE_COBA] = { datatoc_gpu_shader_smoke_vert_glsl, datatoc_gpu_shader_smoke_frag_glsl },
[GPU_SHADER_TEXT] = { datatoc_gpu_shader_text_vert_glsl, datatoc_gpu_shader_text_frag_glsl },
add builtin GPU_SHADER_KEYFRAME_DIAMOND Now we can draw keyframe markers as point sprites, with fewer draw calls and state changes. Based on the builtin shader for round points with anti-aliased outline. This one is more pointy.
2017-02-11 00:02:28 -05:00
[GPU_SHADER_KEYFRAME_DIAMOND] = { datatoc_gpu_shader_keyframe_diamond_vert_glsl,
datatoc_gpu_shader_keyframe_diamond_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_EDGES_FRONT_BACK_PERSP] = { datatoc_gpu_shader_edges_front_back_persp_vert_glsl,
/* this version is */ datatoc_gpu_shader_flat_color_frag_glsl,
/* magical but slooow */ datatoc_gpu_shader_edges_front_back_persp_geom_glsl },
[GPU_SHADER_EDGES_FRONT_BACK_ORTHO] = { datatoc_gpu_shader_edges_front_back_ortho_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
[GPU_SHADER_EDGES_OVERLAY_SIMPLE] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_edges_overlay_frag_glsl,
datatoc_gpu_shader_edges_overlay_simple_geom_glsl },
[GPU_SHADER_EDGES_OVERLAY] = { datatoc_gpu_shader_edges_overlay_vert_glsl,
datatoc_gpu_shader_edges_overlay_frag_glsl,
datatoc_gpu_shader_edges_overlay_geom_glsl },
OpenGL: fix GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR The fragment shader expects a normal, but the vertex shader was not providing one. Fix: added a new vertex shader that has normals + smooth color interpolation. I also split gpu_shader_3D_vert in two: - one with just position - one with position + normal For each of the builtin shaders, we should be able to look at the GLSL and tell exactly what it's doing. Using #defines and #ifdefs for rendering options makes the shaders hard to read and easy to break.
2017-04-16 15:04:07 -04:00
[GPU_SHADER_SIMPLE_LIGHTING] = { datatoc_gpu_shader_3D_normal_vert_glsl, datatoc_gpu_shader_simple_lighting_frag_glsl },
GPU: use ifdef for flat shader
2017-05-16 16:57:26 +10:00
/* Use 'USE_FLAT_NORMAL' to make flat shader from smooth */
[GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR] = { datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl, datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl },
OpenGL: fix GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR The fragment shader expects a normal, but the vertex shader was not providing one. Fix: added a new vertex shader that has normals + smooth color interpolation. I also split gpu_shader_3D_vert in two: - one with just position - one with position + normal For each of the builtin shaders, we should be able to look at the GLSL and tell exactly what it's doing. Using #defines and #ifdefs for rendering options makes the shaders hard to read and easy to break.
2017-04-16 15:04:07 -04:00
[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR] = { datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl, datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl },
Weight painting with draw manager This implements weight rendering with the draw manager, with all drawing options (Shading, wire, face masking, vertex masking). This is part of T51208 Reviewers: campbellbarton Subscribers: dfelinto Differential Revision: https://developer.blender.org/D2654
2017-05-03 18:55:40 +02:00
[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA] = { datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl, datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_mask_uniform_color_frag_glsl },
[GPU_SHADER_3D_IMAGE_MODULATE_ALPHA] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_modulate_alpha_frag_glsl },
[GPU_SHADER_3D_IMAGE_DEPTH] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_depth_linear_frag_glsl },
DRW: Add new Draw Manager OpenGL Context. This separate context allows two things: - It allows viewports in multi-windows configuration. - F12 render can use this context in a separate thread and do a non-blocking render. The downside is that the context cannot be used while rendering so a request to refresh a viewport will lock the UI. This is something that will be adressed in the future. Under the hood what does that mean: - Not adding more mess with VAOs management in gawain. - Doing depth only draw for operators / selection needs to be done in an offscreen buffer. - The 3D cursor "autodis" operator is still reading the backbuffer so we need to copy the result to it. - All FBOs needed by the drawmanager must to be created/destroyed with its context active. - We cannot use batches created for UI in the DRW context and vice-versa. There is a clear separation of resources that enables the use of safe multi-threading.
2018-02-26 19:41:17 +01:00
[GPU_SHADER_3D_IMAGE_DEPTH_COPY] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_depth_copy_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
add builtin GPU_SHADER_KEYFRAME_DIAMOND Now we can draw keyframe markers as point sprites, with fewer draw calls and state changes. Based on the builtin shader for round points with anti-aliased outline. This one is more pointy.
2017-02-11 00:02:28 -05:00
[GPU_SHADER_2D_IMAGE_INTERLACE] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_interlace_frag_glsl },
OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_COLORBAND Introduced a new checker shader to be used mostly on transparent areas. OpenGL immediate mode: interface_draw.c (cont) ui_draw_but_UNITVEC Introduced a new shader to be used for simple lighting.
2017-02-07 13:04:08 +01:00
[GPU_SHADER_2D_CHECKER] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_checker_frag_glsl },
Fix T49861: Interlace stereo drawing This does not address stapling shader in 2.8, though the solution can be similar (own shader, not polutting interlace shader). part of T49043 Reviewers: merwin Differential Revision: https://developer.blender.org/D2440
2017-01-09 17:58:13 +01:00
Add diagonal stripe shader (GPU_SHADER_2D_DIAG_STRIPES) Reviewed By: merwin Differential Revision: https://developer.blender.org/D2512
2017-02-16 21:49:20 -02:00
[GPU_SHADER_2D_DIAG_STRIPES] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_diag_stripes_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_2D_UNIFORM_COLOR] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },
[GPU_SHADER_2D_FLAT_COLOR] = { datatoc_gpu_shader_2D_flat_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
[GPU_SHADER_2D_SMOOTH_COLOR] = { datatoc_gpu_shader_2D_smooth_color_vert_glsl,
datatoc_gpu_shader_2D_smooth_color_frag_glsl },
Eevee: Add tonemapping using ocio. Actually it's done by the Draw Manager, so other engines can use it.
2017-05-11 16:20:10 +02:00
[GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_linear_frag_glsl },
Code cleanup: stop using rectangle textures in window draw, simplify code.
2018-02-13 18:09:58 +01:00
[GPU_SHADER_2D_IMAGE] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_frag_glsl },
convert icon_draw_texture to gawain imm mode replacements
2016-11-18 16:04:25 +01:00
[GPU_SHADER_2D_IMAGE_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_color_frag_glsl },
Fix alpha overlay for sculpt/paint when using core profile Same fundamental problem as fonts -- there is no longer GL_ALPHA format.
2017-04-19 16:52:47 +02:00
[GPU_SHADER_2D_IMAGE_ALPHA_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_alpha_color_frag_glsl },
Code cleanup: stop using rectangle textures in window draw, simplify code.
2018-02-13 18:09:58 +01:00
[GPU_SHADER_2D_IMAGE_ALPHA] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_modulate_alpha_frag_glsl },
OpenGL immediate mode: new shader image shuffle color new shader to draw an image with one isolated channel
2017-02-24 01:07:40 +01:00
[GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_shuffle_color_frag_glsl },
UI: Perf: Make icon_draw_texture use GWN_draw_primitive. This bypass the use of immediate mode for theses drawcalls. Placement and and icon select (via uvs) is done inside the vertex shader.
2018-03-27 23:57:29 +02:00
[GPU_SHADER_2D_IMAGE_RECT_COLOR] = { datatoc_gpu_shader_2D_image_rect_vert_glsl,
datatoc_gpu_shader_image_color_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_3D_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
[GPU_SHADER_3D_UNIFORM_COLOR_U32] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_3D_FLAT_COLOR] = { datatoc_gpu_shader_3D_flat_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
[GPU_SHADER_3D_FLAT_COLOR_U32] = { datatoc_gpu_shader_3D_flat_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_3D_SMOOTH_COLOR] = { datatoc_gpu_shader_3D_smooth_color_vert_glsl,
datatoc_gpu_shader_3D_smooth_color_frag_glsl },
[GPU_SHADER_3D_DEPTH_ONLY] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_depth_only_frag_glsl },
Fix rotation manipulators not clipping Added new shader for clipping, also cleaned up rotation manipulator drawing code a bit. This code should be replaced by new transform manipulators soon, just keeping this working in the meanwhile.
2017-04-05 01:28:48 +02:00
[GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_clipped_uniform_color_vert_glsl,
datatoc_gpu_shader_uniform_color_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
[GPU_SHADER_3D_GROUNDPOINT] = { datatoc_gpu_shader_3D_groundpoint_vert_glsl, datatoc_gpu_shader_point_uniform_color_frag_glsl },
GPU shaders / Clay engine : small renaming / cleanup
2017-02-11 21:15:46 +01:00
[GPU_SHADER_3D_GROUNDLINE] = { datatoc_gpu_shader_3D_passthrough_vert_glsl,
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
datatoc_gpu_shader_uniform_color_frag_glsl,
datatoc_gpu_shader_3D_groundline_geom_glsl },
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
[GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR] = { datatoc_gpu_shader_2D_line_dashed_uniform_color_vert_glsl,
datatoc_gpu_shader_2D_line_dashed_frag_glsl,
datatoc_gpu_shader_2D_line_dashed_geom_glsl },
[GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_line_dashed_uniform_color_vert_glsl,
datatoc_gpu_shader_2D_line_dashed_frag_glsl,
datatoc_gpu_shader_2D_line_dashed_geom_glsl },
OpenGL: wm_gesture uses new imm mode D2376 by @ianwill, part of T49043 review by @merwin Box select, circle select, etc. Introducing the dashed-line shader! See D2376 for more info.
2017-02-24 15:33:09 -05:00
Clay Engine: Prepare for Armature drawing. - Added runtime display matrices to EditBone and bPoseChannel - Added Object space instance vertex shader and modified the simple lighting shader accordingly
2017-02-22 12:46:27 +01:00
[GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR] =
{ datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
datatoc_gpu_shader_simple_lighting_frag_glsl},
[GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR] = { datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl},
GPU shaders / Clay engine : small renaming / cleanup
2017-02-11 21:15:46 +01:00
[GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR] = { datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl},
Object Engine: Ported Force Field object drawing.
2017-04-10 22:22:37 +02:00
[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS] = { datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
Clay Engine: camera drawing
2017-03-04 00:09:22 +01:00
datatoc_gpu_shader_flat_color_frag_glsl},
Object Engine: Ported Force Field object drawing.
2017-04-10 22:22:37 +02:00
[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED] = { datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl},
Clay Engine: camera drawing
2017-03-04 00:09:22 +01:00
[GPU_SHADER_CAMERA] = { datatoc_gpu_shader_instance_camera_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl},
[GPU_SHADER_DISTANCE_LINES] = { datatoc_gpu_shader_instance_distance_line_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl},
Clay-Engine (merge clay-engine) Initial work by Clément Foucault with contributions from Dalai Felinto (mainly per-collection engine settings logic, and depsgraph iterator placeholder). This makes Blender require OpenGL 3.3. Which means Intel graphic card and OSX will break. Disable CLAY_ENGINE in CMake in those cases. This is a prototype render engine intended to help the design of real render engines. This is mainly an engine with enphasis in matcap and ambient occlusion. Implemented Features -------------------- * Clay Render Engine, following the new API, to be used as reference for future engines * A more complete Matcap customization with more options * Per-Collection render engine settings * New Ground Truth AO - not enabled Missing Features ---------------- * Finish object edit mode - Fix shaders to use new matrix - Fix artifacts when edge does off screen - Fix depth issue - Selection sillhouette - Mesh wires - Use mesh normals (for higher quality matcap) - Non-Mesh objects drawing - Widget drawing - Performance issues * Finish mesh edit mode - Derived-Mesh-less edit mode API (mesh_rende.c) * General edit mode - Per-collection edit mode settings * General engines - Per-collection engine settings (they are their, but they still need to be flushed by depsgraph, and used by the drawing code)
2017-02-07 11:20:15 +01:00
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR] =
{ datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_point_uniform_color_frag_glsl },
[GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR] =
{ datatoc_gpu_shader_2D_point_varying_size_varying_color_vert_glsl,
datatoc_gpu_shader_point_varying_color_frag_glsl },
rename built-in point shaders, SMOOTH --> AA Updated shader names and code that uses them. All of these shaders produce round points that are anti-aliased and blended against the background. These were initially named SMOOTH because they replace glEnable(GL_POINT_SMOOTH). But SMOOTH in shader-land refers to vertex attribute interpolation (like glShadeModel(GL_SMOOTH)). Using SMOOTH to mean two things is confusing, so we now use AA to mean "the point is anti-aliased".
2017-02-28 02:18:52 -05:00
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] =
{ datatoc_gpu_shader_2D_point_uniform_size_aa_vert_glsl,
datatoc_gpu_shader_point_uniform_color_aa_frag_glsl },
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] =
{ datatoc_gpu_shader_2D_point_uniform_size_outline_aa_vert_glsl,
datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl },
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_VARYING_COLOR_OUTLINE_AA] =
{ datatoc_gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert_glsl,
datatoc_gpu_shader_point_varying_color_outline_aa_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
[GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_vert_glsl,
datatoc_gpu_shader_point_uniform_color_frag_glsl },
[GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR] = { datatoc_gpu_shader_3D_point_fixed_size_varying_color_vert_glsl,
datatoc_gpu_shader_point_varying_color_frag_glsl },
[GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_point_varying_size_vert_glsl,
datatoc_gpu_shader_point_uniform_color_frag_glsl },
[GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR] =
{ datatoc_gpu_shader_3D_point_varying_size_varying_color_vert_glsl,
datatoc_gpu_shader_point_varying_color_frag_glsl },
rename built-in point shaders, SMOOTH --> AA Updated shader names and code that uses them. All of these shaders produce round points that are anti-aliased and blended against the background. These were initially named SMOOTH because they replace glEnable(GL_POINT_SMOOTH). But SMOOTH in shader-land refers to vertex attribute interpolation (like glShadeModel(GL_SMOOTH)). Using SMOOTH to mean two things is confusing, so we now use AA to mean "the point is anti-aliased".
2017-02-28 02:18:52 -05:00
[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] =
{ datatoc_gpu_shader_3D_point_uniform_size_aa_vert_glsl,
datatoc_gpu_shader_point_uniform_color_aa_frag_glsl },
[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] =
{ datatoc_gpu_shader_3D_point_uniform_size_outline_aa_vert_glsl,
datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl },
Clay Engine: converted Empties to the new instancing method
2017-02-09 20:55:31 +01:00
[GPU_SHADER_INSTANCE_UNIFORM_COLOR] = { datatoc_gpu_shader_instance_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },
Fix T51210: Draw Manager: Support for Metaball Drawing Differential Revision: D2914
2017-11-16 15:12:32 -02:00
[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE] =
Clay Engine: converted Empties to the new instancing method
2017-02-09 20:55:31 +01:00
{ datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
Object Engine: Ported Force Field object drawing.
2017-04-10 22:22:37 +02:00
[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE] =
{ datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
Clay Engine: More Lamp drawing work
2017-03-05 05:22:40 +01:00
[GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR] = { datatoc_gpu_shader_instance_edges_variying_color_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl,
datatoc_gpu_shader_instance_edges_variying_color_geom_glsl},
DwM: Armature: Add distance outline and wire drawing of envelope bones. This is not complete, it does not implement 3D solid drawing of envelope bones. 2D wire is hence always drawn for now. Some notes: I did not try to implement the 'capsule' approach suggested by @fclem, because: 1. I spent enough time on this already, and finally got something working. 2. I managed to get rid of geometry shader completely. 3. Current approach allows us to use same shader for distance outline and envelope wire. It's working fine, except for one glitch - superpositions of envelope outlines do not work as expected, not sure what's wrong here, tried to disable zbuff, enable GL_BLEND, no luck so far... I think we need our own 'background' drawpass to get them working (also to avoid them drawing over the wire lines).
2017-05-17 12:34:06 +02:00
DwM: Armature: add solid envelope bone drawing. Envelope bones are now pretty much identical to old drawing code. Note that currently new DwM drawing code does not seem to care about wire/solid drawing modes at all, guess this is still TODO... For now we hence just get both wire and solid for envelope bones, this can be refined later.
2017-05-18 11:41:59 +02:00
[GPU_SHADER_3D_INSTANCE_BONE_ENVELOPE_SOLID] = { datatoc_gpu_shader_instance_bone_envelope_solid_vert_glsl,
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
datatoc_gpu_shader_simple_lighting_frag_glsl },
DwM: Armature: Cleanup envelope bone code a bit. Mainly adding 'wire' suffix to wire/distance drawing func and shader. Also, match wire vertex shader behavior with solid one regarding head/tail only drawing (i.e. alwas expect head bone mat, never tail one, and assume that if a radius is negative, then we only draw on the other end of the bone).
2017-05-18 12:10:10 +02:00
[GPU_SHADER_3D_INSTANCE_BONE_ENVELOPE_WIRE] = { datatoc_gpu_shader_instance_bone_envelope_wire_vert_glsl,
datatoc_gpu_shader_flat_color_frag_glsl },
Fix T51210: Draw Manager: Support for Metaball Drawing Differential Revision: D2914
2017-11-16 15:12:32 -02:00
Metalball drawing: rename mball helpers to handles and also rename some related functions
2018-02-16 02:01:09 -02:00
[GPU_SHADER_3D_INSTANCE_MBALL_HANDLES] = { datatoc_gpu_shader_instance_mball_handles_vert_glsl,
Fix T51210: Draw Manager: Support for Metaball Drawing Differential Revision: D2914
2017-11-16 15:12:32 -02:00
datatoc_gpu_shader_flat_color_frag_glsl },
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
};
if (builtin_shaders[shader] == NULL) {
/* just a few special cases */
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
const char *defines = NULL;
switch (shader) {
case GPU_SHADER_SMOKE_COBA:
defines = "#define USE_COBA;\n";
break;
case GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE:
defines = "#define UNIFORM_SCALE;\n";
break;
case GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS:
defines = "#define AXIS_NAME;\n";
break;
case GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR:
DwM: Armature: add solid envelope bone drawing. Envelope bones are now pretty much identical to old drawing code. Note that currently new DwM drawing code does not seem to care about wire/solid drawing modes at all, guess this is still TODO... For now we hence just get both wire and solid for envelope bones, this can be refined later.
2017-05-18 11:41:59 +02:00
case GPU_SHADER_3D_INSTANCE_BONE_ENVELOPE_SOLID:
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
defines = "#define USE_INSTANCE_COLOR;\n";
break;
case GPU_SHADER_3D_FLAT_COLOR_U32:
DwM: Use Batch's for drawing selection Use mesh batch cache for mesh selection. Note that we could create the batches and free immediately so they don't take up memory. This resolves a problem where selection was limited to immediate-mode buffer size.
2017-08-17 01:38:07 +10:00
case GPU_SHADER_3D_UNIFORM_COLOR_U32:
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
defines = "#define USE_COLOR_U32;\n";
break;
GPU: use ifdef for flat shader
2017-05-16 16:57:26 +10:00
case GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR:
defines = "#define USE_FLAT_NORMAL;\n";
break;
Use mesh draw cache for back-buffer selection Vertex/weight paint now work with core profile, resolves T51380.
2017-05-05 05:17:31 +10:00
default:
break;
}
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
const GPUShaderStages *stages = builtin_shader_stages + shader;
if (shader == GPU_SHADER_EDGES_FRONT_BACK_PERSP && !GLEW_VERSION_3_2) {
/* TODO: remove after switch to core profile (maybe) */
static const GPUShaderStages legacy_fancy_edges =
{ datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl,
datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl };
stages = &legacy_fancy_edges;
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
if (shader == GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR && !GLEW_VERSION_3_2) {
Reworked version of dashed line shader. Using geometry shader allows us to get rid of the 'line origin' extra vertex attribute, which means dashed shader no longer requires fiddling with those vertex attributes definition, and, most importantly, does not require anymore special drawing code! As you can see, this makes code much simpler, and much less verbose, especially in complex cases. In addition, changed how dashes are handled, to have two 'modes', a simple one with single color (using default "color" uniform name), and a more advanced one allowing more complex and multi-color patterns. Note that since GLSL 1.2 does not support geometry shaders, a hack was added for now (which gives solid lines, but at least does not make Blender crash).
2017-05-01 16:21:53 +02:00
/* Dashed need geometry shader, which are not supported by legacy OpenGL, fallback to solid lines. */
/* TODO: remove after switch to core profile (maybe) */
Cleanup/rename etc. dashed line shaders. Goal is to make them more modular, to allow more variants (variable single-color, thickness, ...) to be added without having to copy-and-change-one-line of whole chain of shaders.
2017-07-13 16:44:02 +02:00
static const GPUShaderStages legacy_dashed_lines = { datatoc_gpu_shader_3D_line_dashed_uniform_color_legacy_vert_glsl,
Reworked version of dashed line shader. Using geometry shader allows us to get rid of the 'line origin' extra vertex attribute, which means dashed shader no longer requires fiddling with those vertex attributes definition, and, most importantly, does not require anymore special drawing code! As you can see, this makes code much simpler, and much less verbose, especially in complex cases. In addition, changed how dashes are handled, to have two 'modes', a simple one with single color (using default "color" uniform name), and a more advanced one allowing more complex and multi-color patterns. Note that since GLSL 1.2 does not support geometry shaders, a hack was added for now (which gives solid lines, but at least does not make Blender crash).
2017-05-01 16:21:53 +02:00
datatoc_gpu_shader_2D_line_dashed_frag_glsl };
stages = &legacy_dashed_lines;
}
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
/* common case */
OpenGL: drop support for EXT_geometry_shader4 See gpu_shader.c for the main changes. EXT_geometry_shader4 brought this feature to GL versions < 3.2, but now it's just cluttering up our code. Soon all platforms will be on version 3.3 so we won't even have to check support at runtime!
2017-04-08 02:21:13 -04:00
builtin_shaders[shader] = GPU_shader_create(stages->vert, stages->frag, stages->geom, NULL, defines);
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
return builtin_shaders[shader];
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
#define MAX_DEFINES 100
void GPU_shader_free_builtin_shaders(void)
{
OpenGL: manage built-in shaders better As our library of built-in shaders grows, it's important to create, access, and discard them efficiently. Lookup via GPU_shader_get_builtin is now constant time instead of linear (# of built-in shaders). This is called very often with our new immediate mode. Creation and discard are unified. Adding a new shader requires fewer steps. 365 lines shorter :D
2016-11-08 22:53:59 -06:00
for (int i = 0; i < GPU_NUM_BUILTIN_SHADERS; ++i) {
if (builtin_shaders[i]) {
GPU_shader_free(builtin_shaders[i]);
builtin_shaders[i] = NULL;
}
OpenGL: new built-in shader for smooth round 3D points w/ outline
2016-10-16 18:43:24 -04:00
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
Copy Permalink