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
dbd7f36da8ec3ac1c2898aee346beecb86aac8a2
blender-archive/source/blender/gpu/intern/gpu_shader.c

1268 lines
43 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
/*
* 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.
*/
Cleanup: add file doxy comments
2018-08-30 01:56:08 +10:00
/** \file blender/gpu/intern/gpu_shader.c
* \ingroup gpu
*/
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#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"
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
#include "BLI_string.h"
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
#include "BLI_string_utils.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"
GPU: Add GC to FBOs and UBOs and centralize all GCs GPUFrameBuffers were being free when no context was attached or in the wrong gl context. This make sure this does not happen again. You can now safely free any gl resource from any thread (well as long as it's not used anymore!).
2018-07-19 15:48:13 +02:00
#include "GPU_context.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[];
GPU: Add GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE. Will be used for probe outline id drawing.
2018-04-17 13:00:09 +02:00
extern char datatoc_gpu_shader_flat_id_frag_glsl[];
UI: Optimize the area border drawing It is was not really a bottleneck but it was triggering my OCD when 1/3rd of the drawcalls in a normal scene were basically only caused by this.
2018-08-23 22:29:29 +02:00
extern char datatoc_gpu_shader_2D_area_borders_vert_glsl[];
UI: Simplify the area border drawing Instead of doing a lot of alpha blended drawing with jittering, use the fragment shader to do the masking using a circle mask. This is much simpler and requires much less resources. Hopefully this may solve the issue we have with the Intels UHD Graphics 620 on linux.
2018-12-01 19:49:31 +01:00
extern char datatoc_gpu_shader_2D_area_borders_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[];
UI: Support for runtime geometry icons
2018-04-20 15:15:10 +02:00
extern char datatoc_gpu_shader_2D_smooth_color_uniform_alpha_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[];
View3D: Atenuate banding artifacts on background gradient. Dithering the output color for 8bit precision framebuffer with bayer matrix. On my tests the bayer matrux patterns are not noticeable at all. Note that it also does that in opengl rendered mode which can be in a much higher bitdepth. We can fix that if that's a problem in the future but I doubt it will.
2018-04-21 16:45:47 +02:00
extern char datatoc_gpu_shader_2D_smooth_color_dithered_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[];
UI: Perf: Batch icons drawcalls together. For this we use a new shader that gets it's data from a uniform array. Vertex shader position the vertices using these data. Using glUniform is way faster than using imm for that matter. Like BLF rendering, UI icons are always (as far as I know) non occluded and displayed above everything else. They also does not overlap with texts so they can be batched at the same time.
2018-03-31 19:32:28 +02:00
extern char datatoc_gpu_shader_2D_image_multi_rect_vert_glsl[];
GPUShader: Add specialized widget base shader. This vertex shader let us draw widgets with batches instead of imm calls.
2018-03-29 03:06:33 +02:00
extern char datatoc_gpu_shader_2D_widget_base_vert_glsl[];
UI: Perf: Port color widgets to batch. This is more for completeness than perf. Shader is tiny bit more complex but we get less overdraw and drawcalls.
2018-04-06 23:54:24 +02:00
extern char datatoc_gpu_shader_2D_widget_base_frag_glsl[];
UI: Perf: Improve ui_draw_dropshadow. Replace the 12 iterations of UI_draw_roundbox_4fv with only one batch. This mean less overdraw and less drawcalls. I had to hack the opacity falloff curve manually to get approximatly the same result as previous technique. I'm sure with a bit more brain power somebody could find the perfect function.
2018-04-06 10:09:23 +02:00
extern char datatoc_gpu_shader_2D_widget_shadow_vert_glsl[];
extern char datatoc_gpu_shader_2D_widget_shadow_frag_glsl[];
GPUShader: Add 2D Nodelink shader. Special shader to draw nodelinks for the node editor. We only pass bezier points to the GPU and vertex position is handled inside the vertex shader. The arrow is also part of the batch to avoid separate drawcalls for it. We still draw 2 pass one for shadow and one for the link color on top. One variation to draw instances of theses links so that we only do one drawcall.
2018-04-05 15:27:53 +02:00
extern char datatoc_gpu_shader_2D_nodelink_frag_glsl[];
extern char datatoc_gpu_shader_2D_nodelink_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[];
UI: desaturate toolbar icons that the mouse is not over. This does not look great with light toolbar buttons as in the default, so consider this a work in progress.
2018-04-26 15:42:08 +02:00
extern char datatoc_gpu_shader_image_desaturate_frag_glsl[];
UI: Perf: Batch icons drawcalls together. For this we use a new shader that gets it's data from a uniform array. Vertex shader position the vertices using these data. Using glUniform is way faster than using imm for that matter. Like BLF rendering, UI icons are always (as far as I know) non occluded and displayed above everything else. They also does not overlap with texts so they can be batched at the same time.
2018-03-31 19:32:28 +02:00
extern char datatoc_gpu_shader_image_varying_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[];
GPUShader: Add GPU_SHADER_2D_IMAGE_MULTISAMPLE_2/4/8/16 This shader is used instead of blitting back and forth to a single sample buffer. This means it resolves the color and depth samples and outputs a fragment which can be depth tested and blended on top of an existing framebuffer. We do static shader variation with manual loop unrolling for performance reason. In my test I get 25% more perf with intel integrated gpu and 75% performance gain with dedicated nvidia card compared to a single shader with a uniform for sample count.
2018-04-23 21:08:11 +02:00
extern char datatoc_gpu_shader_image_multisample_resolve_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[];
GPU: Add GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE. Will be used for probe outline id drawing.
2018-04-17 13:00:09 +02:00
extern char datatoc_gpu_shader_instance_variying_size_variying_id_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[];
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[];
Edit UVs: Refactor drawing Edit UV in Image Editor NOTE: This commit only concern edit UVs and not the "shadow" mesh displayed when texture painting. This will be address in a future commit. We now cache the uv mesh in the mesh batch cache and only reupload data on changes. Update could be more granular (and a bit faster) but it's not our main concern ATM. This should fix problem caused by the IMM api used to draw large meshes. This makes performance skyrocket compared to previous implementation. There is still a big CPU bottleneck when not in sync selection mode but it is not related to the drawing function directly.
2018-09-29 19:42:09 +02:00
extern char datatoc_gpu_shader_point_varying_color_varying_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
Edit UVs: Refactor drawing Edit UV in Image Editor NOTE: This commit only concern edit UVs and not the "shadow" mesh displayed when texture painting. This will be address in a future commit. We now cache the uv mesh in the mesh batch cache and only reupload data on changes. Update could be more granular (and a bit faster) but it's not our main concern ATM. This should fix problem caused by the IMM api used to draw large meshes. This makes performance skyrocket compared to previous implementation. There is still a big CPU bottleneck when not in sync selection mode but it is not related to the drawing function directly.
2018-09-29 19:42:09 +02:00
extern char datatoc_gpu_shader_2D_edituvs_points_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_facedots_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_edges_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_faces_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl[];
GPUShader: Add selection id shader This is to separate id drawing from standard color drawing.
2018-12-22 21:02:30 +01:00
extern char datatoc_gpu_shader_3D_selection_id_vert_glsl[];
extern char datatoc_gpu_shader_selection_id_frag_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_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[];
BLF: Perf: Divide by 6 the amount of verts sent to the GPU. This means smaller imm buffer usage. This does not reduce the number of drawcalls. This uses geometry shader which is slow for the GPU but given we are really CPU bound on this case, it should not matter. A perfect implementation would: - Set the glyph coord in a bufferTexture and just send the glyph ID to the GPU to read the bufferTexture. - Use GWN_draw_primitive and draw 2*strllen triangle and just retrieve the glyph ID and color based on gl_VertexID / 6. - Stream fixed size buffer that the Driver can discard quickly but this is the same as improving IMM directly.
2018-03-29 20:22:31 +02:00
extern char datatoc_gpu_shader_text_geom_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_frag_glsl[];
BFL: Fix broken vertical texts. I've made a separate version of the geom shader that works with full 3D modelviewmat. This commit also includes some fixup inside blf_batching_start().
2018-03-30 22:50:17 +02:00
extern char datatoc_gpu_shader_text_simple_vert_glsl[];
extern char datatoc_gpu_shader_text_simple_geom_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
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
extern char datatoc_gpu_shader_gpencil_stroke_vert_glsl[];
extern char datatoc_gpu_shader_gpencil_stroke_frag_glsl[];
extern char datatoc_gpu_shader_gpencil_stroke_geom_glsl[];
extern char datatoc_gpu_shader_gpencil_fill_vert_glsl[];
extern char datatoc_gpu_shader_gpencil_fill_frag_glsl[];
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
extern char datatoc_gpu_shader_cfg_world_clip_lib_glsl[];
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02: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
/* cache of built-in shaders (each is created on first use) */
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
static GPUShader *builtin_shaders[GPU_SHADER_CFG_LEN][GPU_SHADER_BUILTIN_LEN] = {NULL};
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
GPUShader: Fix warning in release build.
2018-08-03 14:34:05 +02:00
#ifndef NDEBUG
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
static uint g_shaderid = 0;
GPUShader: Fix warning in release build.
2018-08-03 14:34:05 +02:00
#endif
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02: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;
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
/** Optional. */
const char *geom;
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 char *frag;
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
/** Optional. */
const char *defs;
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
} 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++;
}
Cleanup: strip trailing space in GPU module
2018-06-04 09:09:12 +02:00
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
fprintf(stderr, "%s", c);
}
}
Cleanup: strip trailing space in GPU module
2018-06-04 09:09:12 +02:00
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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!
*/
Fix T55802 shader compile bug with texture gather on old Nvidia card The extension GL_ARB_texture_gather is reported to be supported and does not trigger an error when enabled but the textureGater functions are not defined. Workaround is to disable the use of this extension on such systems.
2018-08-13 11:48:44 +02:00
if (GLEW_ARB_texture_gather) {
/* There is a bug on older Nvidia GPU where GL_ARB_texture_gather
* is reported to be supported but yield a compile error (see T55802). */
if (!GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY) || GLEW_VERSION_4_0) {
strcat(defines, "#extension GL_ARB_texture_gather: enable\n");
Fix T56544: Crash on startup with Radeon + Win 7 Testing GLEW_ARB_texture_gather is not sufficient in this case. We need to test if GL_ARB_texture_gather is defined in the shader, which is always true on some NVIDIA drivers who does not support it... So trying to make everything work.
2018-09-03 19:20:56 +02:00
/* Some drivers don't agree on GLEW_ARB_texture_gather and the actual support in the
* shader so double check the preprocessor define (see T56544). */
if (!GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY) && !GLEW_VERSION_4_0) {
strcat(defines, "#ifdef GL_ARB_texture_gather\n");
strcat(defines, "# define GPU_ARB_texture_gather\n");
strcat(defines, "#endif\n");
}
else {
strcat(defines, "#define GPU_ARB_texture_gather\n");
}
Fix T55802 shader compile bug with texture gather on old Nvidia card The extension GL_ARB_texture_gather is reported to be supported and does not trigger an error when enabled but the textureGater functions are not defined. Workaround is to disable the use of this extension on such systems.
2018-08-13 11:48:44 +02:00
}
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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");
}
}
GPU: Remove residue of OpenSubdiv Was done more like a hack on top of old drawing pipeline. Should be re-implemented to fit new draw manager closer.
2018-09-12 14:30:28 +02:00
static void gpu_shader_standard_defines(char defines[MAX_DEFINE_LENGTH])
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 */
Cleanup: Rename GPU_* functions to make more sense * Remove GPU_link_changed which is unused. * Remove all GPU link function that are not used anymore. * GPU_uniform_buffer is now GPU_uniform. * GPU_texture_ramp is now GPU_color_band. * GPU_uniform is now GPU_constant.
2018-08-13 15:30:29 +02:00
if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY))
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
strcat(defines, "#define GPU_ATI\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");
return;
}
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
GPUShader *GPU_shader_create(
const char *vertexcode,
const char *fragcode,
const char *geocode,
const char *libcode,
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
const char *defines,
const char *shname)
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
return GPU_shader_create_ex(
vertexcode,
fragcode,
geocode,
libcode,
defines,
GPU_SHADER_TFB_NONE,
NULL,
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
0,
shname);
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
#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.
Spelling fixes in comments and descriptions, patch by luzpaz. Differential Revision: https://developer.blender.org/D3719
2018-09-24 17:27:41 +02:00
* So we call this function once before calling for the individual shaders. */
--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
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);
}
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
GPUShader *GPU_shader_create_ex(
const char *vertexcode,
const char *fragcode,
const char *geocode,
const char *libcode,
const char *defines,
Cleanup: use eGPU prefix for GPU enum types
2019-01-23 14:15:43 +11:00
const eGPUShaderTFBType tf_type,
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
const char **tf_names,
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
const int tf_count,
const char *shname)
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
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
GPUShader: Add name for debugging & identifying shaders.
2018-08-02 18:31:38 +02:00
#ifndef NDEBUG
BLI_snprintf(shader->name, sizeof(shader->name), "%s_%u", shname, g_shaderid++);
#else
UNUSED_VARS(shname);
#endif
GPU: Remove EXT and add assert Some drivers accept shaders with only vertex stage, but some just silently fails.
2018-12-07 04:07:56 +01:00
/* At least a vertex shader and a fragment shader are required. */
GPUShader: Add GPU_VERTEX/FRAGMENT/GEOMETRY_SHADER defines This makes it possible to have some code specific to each shader inside a shader library.
2019-01-21 12:50:57 +01:00
BLI_assert((fragcode != NULL) && (vertexcode != NULL));
GPU: Remove EXT and add assert Some drivers accept shaders with only vertex stage, but some just silently fails.
2018-12-07 04:07:56 +01:00
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)
GPU: Remove EXT and add assert Some drivers accept shaders with only vertex stage, but some just silently fails.
2018-12-07 04:07:56 +01:00
shader->geometry = glCreateShader(GL_GEOMETRY_SHADER);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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;
}
GPU: Remove residue of OpenSubdiv Was done more like a hack on top of old drawing pipeline. Should be re-implemented to fit new draw manager closer.
2018-09-12 14:30:28 +02:00
gpu_shader_standard_defines(standard_defines);
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) {
GPUShader: Add GPU_VERTEX/FRAGMENT/GEOMETRY_SHADER defines This makes it possible to have some code specific to each shader inside a shader library.
2019-01-21 12:50:57 +01:00
const char *source[6];
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
/* custom limit, may be too small, beware */
int num_source = 0;
source[num_source++] = gpu_shader_version();
GPUShader: Add GPU_VERTEX/FRAGMENT/GEOMETRY_SHADER defines This makes it possible to have some code specific to each shader inside a shader library.
2019-01-21 12:50:57 +01:00
source[num_source++] = "#define GPU_VERTEX_SHADER\n";
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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();
GPUShader: Add GPU_VERTEX/FRAGMENT/GEOMETRY_SHADER defines This makes it possible to have some code specific to each shader inside a shader library.
2019-01-21 12:50:57 +01:00
source[num_source++] = "#define GPU_FRAGMENT_SHADER\n";
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
source[num_source++] = standard_extensions;
source[num_source++] = standard_defines;
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();
GPUShader: Add GPU_VERTEX/FRAGMENT/GEOMETRY_SHADER defines This makes it possible to have some code specific to each shader inside a shader library.
2019-01-21 12:50:57 +01:00
source[num_source++] = "#define GPU_GEOMETRY_SHADER\n";
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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;
}
}
GPUShader/DRW: Add Transform Feedback support. This is a usefull feature that can be used to do a lot of precomputation on the GPU instead of the CPU. Implementation is simple and only covers the most usefull case. How to use: - Create shader with transform feedback. - Create a pass with DRW_STATE_TRANS_FEEDBACK. - Create a target Gwn_VertBuf (make sure it's big enough). - Create a shading group with DRW_shgroup_transform_feedback_create(). - Add your draw calls to the shading group. - Render your pass normaly. Current limitation: - Only one output buffer. - Cannot pause/resume tfb rendering to interleave with normal drawcalls. - Cannot get the number of verts drawn.
2018-05-16 12:47:15 +02:00
if (tf_names != NULL) {
glTransformFeedbackVaryings(shader->program, tf_count, tf_names, GL_INTERLEAVED_ATTRIBS);
/* Primitive type must be setup */
BLI_assert(tf_type != GPU_SHADER_TFB_NONE);
shader->feedback_transform_type = tf_type;
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
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;
}
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
shader->interface = GPU_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
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
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
static const char *string_join_array_maybe_alloc(const char **str_arr, bool *r_is_alloc)
{
bool is_alloc = false;
if (str_arr == NULL) {
*r_is_alloc = false;
return NULL;
}
/* Skip empty strings (avoid alloc if we can). */
while (str_arr[0] && str_arr[0][0] == '\0') {
str_arr++;
}
int i;
for (i = 0; str_arr[i]; i++) {
if (i != 0 && str_arr[i][0] != '\0') {
is_alloc = true;
}
}
*r_is_alloc = is_alloc;
if (is_alloc) {
return BLI_string_join_arrayN(str_arr, i);
}
else {
return str_arr[0];
}
}
/**
* Use via #GPU_shader_create_from_arrays macro (avoids passing in param).
*
* Similar to #DRW_shader_create_with_lib with the ability to include libs for each type of shader.
*
* It has the advantage that each item can be conditionally included
* without having to build the string inline, then free it.
*
* \param params: NULL terminated arrays of strings.
*
* Example:
* \code{.c}
* sh = GPU_shader_create_from_arrays({
* .vert = (const char *[]){shader_lib_glsl, shader_vert_glsl, NULL},
* .geom = (const char *[]){shader_geom_glsl, NULL},
* .frag = (const char *[]){shader_frag_glsl, NULL},
* .defs = (const char *[]){"#define DEFINE\n", test ? "#define OTHER_DEFINE\n" : "", NULL},
* });
* \endcode
*/
struct GPUShader *GPU_shader_create_from_arrays_impl(
const struct GPU_ShaderCreateFromArray_Params *params)
{
struct { const char *str; bool is_alloc;} str_dst[4] = {0};
const char **str_src[4] = {params->vert, params->frag, params->geom, params->defs};
for (int i = 0; i < ARRAY_SIZE(str_src); i++) {
str_dst[i].str = string_join_array_maybe_alloc(str_src[i], &str_dst[i].is_alloc);
}
GPUShader *sh = GPU_shader_create(
str_dst[0].str, str_dst[1].str, str_dst[2].str, NULL, str_dst[3].str, __func__);
for (int i = 0; i < ARRAY_SIZE(str_dst); i++) {
if (str_dst[i].is_alloc) {
MEM_freeN((void *)str_dst[i].str);
}
}
return sh;
}
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);
GPU_matrix: use Blender's naming conventions Thanks to @sergey for review
2018-07-15 15:27:15 +02:00
GPU_matrix_bind(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);
}
Cleanup: use uint/uchar types in GPU
2018-09-12 12:18:35 +10:00
bool GPU_shader_transform_feedback_enable(GPUShader *shader, uint vbo_id)
GPUShader/DRW: Add Transform Feedback support. This is a usefull feature that can be used to do a lot of precomputation on the GPU instead of the CPU. Implementation is simple and only covers the most usefull case. How to use: - Create shader with transform feedback. - Create a pass with DRW_STATE_TRANS_FEEDBACK. - Create a target Gwn_VertBuf (make sure it's big enough). - Create a shading group with DRW_shgroup_transform_feedback_create(). - Add your draw calls to the shading group. - Render your pass normaly. Current limitation: - Only one output buffer. - Cannot pause/resume tfb rendering to interleave with normal drawcalls. - Cannot get the number of verts drawn.
2018-05-16 12:47:15 +02:00
{
if (shader->feedback_transform_type == GPU_SHADER_TFB_NONE) {
return false;
}
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbo_id);
switch (shader->feedback_transform_type) {
case GPU_SHADER_TFB_POINTS: glBeginTransformFeedback(GL_POINTS); return true;
case GPU_SHADER_TFB_LINES: glBeginTransformFeedback(GL_LINES); return true;
case GPU_SHADER_TFB_TRIANGLES: glBeginTransformFeedback(GL_TRIANGLES); return true;
default: return false;
}
}
void GPU_shader_transform_feedback_disable(GPUShader *UNUSED(shader))
{
glEndTransformFeedback();
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
void GPU_shader_free(GPUShader *shader)
{
GPUMaterial: Fix assert when shader failed to compile.
2018-08-01 21:45:43 +02:00
#if 0 /* Would be nice to have, but for now the Deferred compilation
* does not have a GPUContext. */
GPU: Add GC to FBOs and UBOs and centralize all GCs GPUFrameBuffers were being free when no context was attached or in the wrong gl context. This make sure this does not happen again. You can now safely free any gl resource from any thread (well as long as it's not used anymore!).
2018-07-19 15:48:13 +02:00
BLI_assert(GPU_context_active_get() != NULL);
GPUMaterial: Fix assert when shader failed to compile.
2018-08-01 21:45:43 +02:00
#endif
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)
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
GPU_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);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUShaderInput *uniform = GPU_shaderinterface_uniform(shader->interface, name);
DRW: Use name buffer to request uniform location before drawing. This is in order to avoid GL call during the "cache creation" phase and support multithreading.
2019-01-17 18:33:08 +01:00
return uniform ? uniform->location : -2;
GPU: Rename GPU_shader_get_uniform to GPU_shader_get_uniform_ensure This is in order to make the API more multithread friendly inside the draw manager. GPU_shader_get_uniform will only serve to query the shader interface and not do any GL call, making it threadsafe. For now it only print a warning if the uniform was not queried before.
2019-01-16 04:41:27 +01:00
}
int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name)
{
BLI_assert(shader && shader->program);
const GPUShaderInput *uniform = GPU_shaderinterface_uniform_ensure(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);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUShaderInput *uniform = GPU_shaderinterface_uniform_builtin(shader->interface, builtin);
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
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);
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
const GPUShaderInput *ubo = GPU_shaderinterface_ubo(shader->interface, name);
Gawain: Add UBOs to shader interface.
2017-10-06 14:57:21 +02:00
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;
}
GPU Python API: shader.uniform_float The existing alternative is to use a buffer and call uniform_vector_float which is overkill for such a simple operation.
2018-09-20 19:51:02 +00:00
void GPU_shader_uniform_float(GPUShader *UNUSED(shader), int location, float value)
{
if (location == -1)
return;
glUniform1f(location, value);
}
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);
Cleanup: replace attrib w/ attr Also rename GPUVertexAttribs to GPUVertAttrLayers, avoids confusion with GPUVertAttr which isn't closely related.
2019-01-29 07:46:25 +11:00
const GPUShaderInput *attr = GPU_shaderinterface_attr(shader->interface, name);
return attr ? attr->location : -1;
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
static const GPUShaderStages builtin_shader_stages[GPU_SHADER_BUILTIN_LEN] = {
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
[GPU_SHADER_TEXT] = {
.vert = datatoc_gpu_shader_text_vert_glsl,
.geom = datatoc_gpu_shader_text_geom_glsl,
.frag = datatoc_gpu_shader_text_frag_glsl,
},
[GPU_SHADER_TEXT_SIMPLE] = {
.vert = datatoc_gpu_shader_text_simple_vert_glsl,
.geom = datatoc_gpu_shader_text_simple_geom_glsl,
.frag = datatoc_gpu_shader_text_frag_glsl,
},
[GPU_SHADER_KEYFRAME_DIAMOND] = {
.vert = datatoc_gpu_shader_keyframe_diamond_vert_glsl,
.frag = datatoc_gpu_shader_keyframe_diamond_frag_glsl,
},
/* This version is magical but slow! */
[GPU_SHADER_EDGES_FRONT_BACK_PERSP] = {
.vert = datatoc_gpu_shader_edges_front_back_persp_vert_glsl,
.geom = datatoc_gpu_shader_edges_front_back_persp_geom_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_EDGES_FRONT_BACK_ORTHO] = {
.vert = datatoc_gpu_shader_edges_front_back_ortho_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_EDGES_OVERLAY_SIMPLE] = {
.vert = datatoc_gpu_shader_3D_vert_glsl,
.geom = datatoc_gpu_shader_edges_overlay_simple_geom_glsl,
.frag = datatoc_gpu_shader_edges_overlay_frag_glsl,
},
[GPU_SHADER_EDGES_OVERLAY] = {
.vert = datatoc_gpu_shader_edges_overlay_vert_glsl,
.geom = datatoc_gpu_shader_edges_overlay_geom_glsl,
.frag = datatoc_gpu_shader_edges_overlay_frag_glsl,
},
[GPU_SHADER_SIMPLE_LIGHTING] = {
.vert = datatoc_gpu_shader_3D_normal_vert_glsl,
.frag = datatoc_gpu_shader_simple_lighting_frag_glsl,
},
GPU module: Initial implementation of the `gpu.shader` submodule. Differential Revision: https://developer.blender.org/D3688
2018-09-14 09:32:19 -03:00
/* Use 'USE_FLAT_NORMAL' to make flat shader from smooth */
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
[GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR] = {
.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define USE_FLAT_NORMAL\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR] = {
.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl,
},
[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA] = {
.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_mask_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_IMAGE_MODULATE_ALPHA] = {
.vert = datatoc_gpu_shader_3D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_modulate_alpha_frag_glsl,
},
[GPU_SHADER_3D_IMAGE_DEPTH] = {
.vert = datatoc_gpu_shader_3D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_depth_linear_frag_glsl,
},
[GPU_SHADER_3D_IMAGE_DEPTH_COPY] = {
.vert = datatoc_gpu_shader_3D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_depth_copy_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_2] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 2\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_4] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 4\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_8] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 8\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_16] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 16\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 2\n"
"#define USE_DEPTH\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 4\n"
"#define USE_DEPTH\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 8\n"
"#define USE_DEPTH\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SAMPLES 16\n"
"#define USE_DEPTH\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_IMAGE_INTERLACE] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_interlace_frag_glsl,
},
[GPU_SHADER_2D_CHECKER] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_checker_frag_glsl,
},
[GPU_SHADER_2D_DIAG_STRIPES] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_diag_stripes_frag_glsl,
},
[GPU_SHADER_2D_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
},
[GPU_SHADER_2D_FLAT_COLOR] = {
.vert = datatoc_gpu_shader_2D_flat_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_2D_SMOOTH_COLOR] = {
.vert = datatoc_gpu_shader_2D_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
},
[GPU_SHADER_2D_SMOOTH_COLOR_DITHER] = {
.vert = datatoc_gpu_shader_2D_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_2D_smooth_color_dithered_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_linear_frag_glsl,
},
[GPU_SHADER_2D_IMAGE] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_color_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_DESATURATE_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_desaturate_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_ALPHA_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_alpha_color_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_vert_glsl,
.frag = datatoc_gpu_shader_image_shuffle_color_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_RECT_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_rect_vert_glsl,
.frag = datatoc_gpu_shader_image_color_frag_glsl,
},
[GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR] = {
.vert = datatoc_gpu_shader_2D_image_multi_rect_vert_glsl,
.frag = datatoc_gpu_shader_image_varying_color_frag_glsl,
},
[GPU_SHADER_3D_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_UNIFORM_COLOR_BACKGROUND] = {
.vert = datatoc_gpu_shader_3D_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define USE_BACKGROUND\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_3D_FLAT_COLOR] = {
.vert = datatoc_gpu_shader_3D_flat_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_3D_SMOOTH_COLOR] = {
.vert = datatoc_gpu_shader_3D_smooth_color_vert_glsl,
.frag = datatoc_gpu_shader_3D_smooth_color_frag_glsl,
},
[GPU_SHADER_3D_DEPTH_ONLY] = {
.vert = datatoc_gpu_shader_3D_vert_glsl,
.frag = datatoc_gpu_shader_depth_only_frag_glsl,
},
[GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_clipped_uniform_color_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_GROUNDPOINT] = {
Cleanup: style, unused variable
2019-01-31 15:54:37 +11:00
.vert = datatoc_gpu_shader_3D_groundpoint_vert_glsl,
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_GROUNDLINE] = {
.vert = datatoc_gpu_shader_3D_passthrough_vert_glsl,
.geom = datatoc_gpu_shader_3D_groundline_geom_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
},
[GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_2D_line_dashed_uniform_color_vert_glsl,
.geom = datatoc_gpu_shader_2D_line_dashed_geom_glsl,
.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl,
},
[GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_line_dashed_uniform_color_vert_glsl,
.geom = datatoc_gpu_shader_2D_line_dashed_geom_glsl,
.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl,
},
[GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR] = {
.vert = datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
.frag = datatoc_gpu_shader_simple_lighting_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define USE_INSTANCE_COLOR\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR] = {
.vert = datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR] = {
.vert = datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS] = {
.vert = datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define AXIS_NAME\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED] = {
.vert = datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_CAMERA] = {
.vert = datatoc_gpu_shader_instance_camera_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_DISTANCE_LINES] = {
.vert = datatoc_gpu_shader_instance_distance_line_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
},
[GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR] = {
.vert = datatoc_gpu_shader_2D_point_varying_size_varying_color_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
},
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] = {
.vert = datatoc_gpu_shader_2D_point_uniform_size_aa_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_aa_frag_glsl,
},
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] = {
.vert = datatoc_gpu_shader_2D_point_uniform_size_outline_aa_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl,
},
[GPU_SHADER_2D_POINT_UNIFORM_SIZE_VARYING_COLOR_OUTLINE_AA] = {
.vert = datatoc_gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_outline_aa_frag_glsl,
},
[GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR] = {
.vert = datatoc_gpu_shader_3D_point_fixed_size_varying_color_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
},
[GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_3D_point_varying_size_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
},
[GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR] = {
.vert = datatoc_gpu_shader_3D_point_varying_size_varying_color_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
},
[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] = {
.vert = datatoc_gpu_shader_3D_point_uniform_size_aa_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_aa_frag_glsl,
},
[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] = {
.vert = datatoc_gpu_shader_3D_point_uniform_size_outline_aa_vert_glsl,
.frag = datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl,
},
[GPU_SHADER_INSTANCE_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_instance_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
},
[GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE] = {
.vert = datatoc_gpu_shader_instance_variying_size_variying_id_vert_glsl,
.frag = datatoc_gpu_shader_flat_id_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define UNIFORM_SCALE\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE] = {
.vert = datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define UNIFORM_SCALE\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE] = {
.vert = datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR] = {
.vert = datatoc_gpu_shader_instance_edges_variying_color_vert_glsl,
.geom = datatoc_gpu_shader_instance_edges_variying_color_geom_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_2D_AREA_EDGES] = {
.vert = datatoc_gpu_shader_2D_area_borders_vert_glsl,
.frag = datatoc_gpu_shader_2D_area_borders_frag_glsl,
},
[GPU_SHADER_2D_WIDGET_BASE] = {
.vert = datatoc_gpu_shader_2D_widget_base_vert_glsl,
.frag = datatoc_gpu_shader_2D_widget_base_frag_glsl,
},
[GPU_SHADER_2D_WIDGET_BASE_INST] = {
.vert = datatoc_gpu_shader_2D_widget_base_vert_glsl,
.frag = datatoc_gpu_shader_2D_widget_base_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define USE_INSTANCE\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_WIDGET_SHADOW] = {
.vert = datatoc_gpu_shader_2D_widget_shadow_vert_glsl,
.frag = datatoc_gpu_shader_2D_widget_shadow_frag_glsl,
},
[GPU_SHADER_2D_NODELINK] = {
.vert = datatoc_gpu_shader_2D_nodelink_vert_glsl,
.frag = datatoc_gpu_shader_2D_nodelink_frag_glsl,
},
[GPU_SHADER_2D_NODELINK_INST] = {
.vert = datatoc_gpu_shader_2D_nodelink_vert_glsl,
.frag = datatoc_gpu_shader_2D_nodelink_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define USE_INSTANCE\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_UV_UNIFORM_COLOR] = {
.vert = datatoc_gpu_shader_2D_vert_glsl,
.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define UV_POS\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_UV_VERTS] = {
.vert = datatoc_gpu_shader_2D_edituvs_points_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl,
},
[GPU_SHADER_2D_UV_FACEDOTS] = {
.vert = datatoc_gpu_shader_2D_edituvs_facedots_vert_glsl,
.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
},
[GPU_SHADER_2D_UV_EDGES] = {
.vert = datatoc_gpu_shader_2D_edituvs_edges_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_2D_UV_EDGES_SMOOTH] = {
.vert = datatoc_gpu_shader_2D_edituvs_edges_vert_glsl,
.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define SMOOTH_COLOR\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_2D_UV_FACES] = {
.vert = datatoc_gpu_shader_2D_edituvs_faces_vert_glsl,
.frag = datatoc_gpu_shader_flat_color_frag_glsl,
},
[GPU_SHADER_2D_UV_FACES_STRETCH_AREA] = {
.vert = datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl,
.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
},
[GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE] = {
.vert = datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl,
.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define STRETCH_ANGLE\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_3D_FLAT_SELECT_ID] = {
.vert = datatoc_gpu_shader_3D_selection_id_vert_glsl,
.frag = datatoc_gpu_shader_selection_id_frag_glsl,
},
[GPU_SHADER_3D_UNIFORM_SELECT_ID] = {
.vert = datatoc_gpu_shader_3D_selection_id_vert_glsl,
.frag = datatoc_gpu_shader_selection_id_frag_glsl,
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
.defs =
"#define UNIFORM_ID\n",
Cleanup: order GPUShaderStages (vert, geom, frag) Use names for declarations to support adding defines, coming next.
2019-01-26 09:46:29 +11:00
},
[GPU_SHADER_GPENCIL_STROKE] = {
.vert = datatoc_gpu_shader_gpencil_stroke_vert_glsl,
.geom = datatoc_gpu_shader_gpencil_stroke_geom_glsl,
.frag = datatoc_gpu_shader_gpencil_stroke_frag_glsl,
},
[GPU_SHADER_GPENCIL_FILL] = {
.vert = datatoc_gpu_shader_gpencil_fill_vert_glsl,
.frag = datatoc_gpu_shader_gpencil_fill_frag_glsl,
},
GPU module: Initial implementation of the `gpu.shader` submodule. Differential Revision: https://developer.blender.org/D3688
2018-09-14 09:32:19 -03:00
};
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
GPUShader *GPU_shader_get_builtin_shader_with_config(
eGPUBuiltinShader shader, eGPUShaderConfig shader_cfg)
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
{
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
BLI_assert(shader < GPU_SHADER_BUILTIN_LEN);
BLI_assert(shader_cfg < GPU_SHADER_CFG_LEN);
GPUShader **sh_p = &builtin_shaders[shader_cfg][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
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
if (*sh_p == NULL) {
Cleanup: avoid static vars to store legacy shaders
2019-01-26 10:31:53 +11:00
GPUShaderStages stages_legacy = {NULL};
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
const GPUShaderStages *stages = &builtin_shader_stages[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
Cleanup: avoid static vars to store legacy shaders
2019-01-26 10:31:53 +11:00
if (shader == GPU_SHADER_EDGES_FRONT_BACK_PERSP) {
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
/* TODO: remove after switch to core profile (maybe) */
Cleanup: avoid static vars to store legacy shaders
2019-01-26 10:31:53 +11:00
if (!GLEW_VERSION_3_2) {
stages_legacy.vert = datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl;
stages_legacy.frag = datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl;
stages = &stages_legacy;
}
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
}
Cleanup: avoid static vars to store legacy shaders
2019-01-26 10:31:53 +11:00
else if (shader == GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR) {
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: avoid static vars to store legacy shaders
2019-01-26 10:31:53 +11:00
if (!GLEW_VERSION_3_2) {
stages_legacy.vert = datatoc_gpu_shader_3D_line_dashed_uniform_color_legacy_vert_glsl;
stages_legacy.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl;
stages = &stages_legacy;
}
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
}
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 */
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
if (shader_cfg == GPU_SHADER_CFG_DEFAULT) {
*sh_p = GPU_shader_create(stages->vert, stages->frag, stages->geom, NULL, stages->defs, __func__);
}
else if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
/* Remove eventually, for now ensure support for each shader has been added. */
BLI_assert(ELEM(shader,
GPU_SHADER_3D_UNIFORM_COLOR,
GPU_SHADER_3D_SMOOTH_COLOR,
GPU_SHADER_3D_DEPTH_ONLY,
GPU_SHADER_CAMERA,
GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE,
GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE,
GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR,
GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED,
GPU_SHADER_3D_GROUNDLINE,
GPU_SHADER_3D_GROUNDPOINT,
GPU_SHADER_DISTANCE_LINES,
GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR));
const char *world_clip_lib = datatoc_gpu_shader_cfg_world_clip_lib_glsl;
const char *world_clip_def = "#define USE_WORLD_CLIP_PLANES\n";
/* In rare cases geometry shaders calculate clipping themselves. */
*sh_p = GPU_shader_create_from_arrays({
.vert = (const char *[]){world_clip_lib, stages->vert, NULL},
.geom = (const char *[]){stages->geom ? world_clip_lib : NULL, stages->geom, NULL},
.frag = (const char *[]){stages->frag, NULL},
.defs = (const char *[]){world_clip_def, stages->defs, NULL},
});
}
else {
BLI_assert(0);
}
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
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
return *sh_p;
}
GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader)
{
return GPU_shader_get_builtin_shader_with_config(shader, GPU_SHADER_CFG_DEFAULT);
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
}
GPU module: Initial implementation of the `gpu.shader` submodule. Differential Revision: https://developer.blender.org/D3688
2018-09-14 09:32:19 -03:00
void GPU_shader_get_builtin_shader_code(
Cleanup: use eGPU prefix for GPU enum types
2019-01-23 14:15:43 +11:00
eGPUBuiltinShader shader,
Cleanup: use r_ prefix for return args
2018-09-15 08:00:29 +10:00
const char **r_vert, const char **r_frag,
const char **r_geom, const char **r_defines)
GPU module: Initial implementation of the `gpu.shader` submodule. Differential Revision: https://developer.blender.org/D3688
2018-09-14 09:32:19 -03:00
{
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
const GPUShaderStages *stages = &builtin_shader_stages[shader];
Cleanup: use r_ prefix for return args
2018-09-15 08:00:29 +10:00
*r_vert = stages->vert;
*r_frag = stages->frag;
*r_geom = stages->geom;
GPU: refactor defines into GPUShaderStages Code comment notes there are "just a few", now there are enough it's useful to include in GPUShaderStages.
2019-01-26 10:04:10 +11:00
*r_defines = stages->defs;
GPU module: Initial implementation of the `gpu.shader` submodule. Differential Revision: https://developer.blender.org/D3688
2018-09-14 09:32:19 -03:00
}
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
void GPU_shader_free_builtin_shaders(void)
{
GPU: refactor clipped drawing from DRW into GPU Needed to fix T61196, supporting clipped back-buffer in the 3D view which is done outside the draw module. It was also inconvenient having DRW_shader_* versions of GPU_shader_* API calls. - Clipping distances are now supported as a shader configuration for builtin shaders. - Add shader config argument when accessing builtin shaders. - Move GPU_shader_create_from_arrays() from DRW to GPU.
2019-02-06 09:15:16 +11:00
for (int i = 0; i < GPU_SHADER_CFG_LEN; i++) {
for (int j = 0; j < GPU_SHADER_BUILTIN_LEN; j++) {
if (builtin_shaders[i][j]) {
GPU_shader_free(builtin_shaders[i][j]);
builtin_shaders[i][j] = NULL;
}
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: 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