diff options
Diffstat (limited to 'source/blender/draw/engines/workbench')
29 files changed, 3646 insertions, 0 deletions
diff --git a/source/blender/draw/engines/workbench/shaders/workbench_background_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_background_lib.glsl new file mode 100644 index 00000000000..fda2fc85460 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_background_lib.glsl @@ -0,0 +1,3 @@ +vec3 background_color(WorldData world_data, float y) { + return mix(world_data.background_color_low, world_data.background_color_high, y).xyz + bayer_dither_noise(); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_cavity_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_cavity_frag.glsl new file mode 100644 index 00000000000..38f55015877 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_cavity_frag.glsl @@ -0,0 +1,71 @@ +out vec4 fragColor; + +uniform sampler2D depthBuffer; +uniform sampler2D colorBuffer; +uniform sampler2D normalBuffer; +uniform sampler2D positionBuffer; + +uniform vec2 invertedViewportSize; +uniform mat4 WinMatrix; /* inverse WinMatrix */ + +uniform vec4 viewvecs[3]; +uniform vec4 ssao_params; +uniform vec4 ssao_settings; +uniform sampler2D ssao_jitter; + +layout(std140) uniform samples_block { + vec4 ssao_samples[500]; +}; + +#define ssao_samples_num ssao_params.x +#define jitter_tilling ssao_params.yz +#define dfdy_sign ssao_params.w + +#define ssao_distance ssao_settings.x +#define ssao_factor_cavity ssao_settings.y +#define ssao_factor_edge ssao_settings.z +#define ssao_attenuation ssao_settings.a + +vec3 get_view_space_from_depth(in vec2 uvcoords, in float depth) +{ + if (WinMatrix[3][3] == 0.0) { + /* Perspective */ + float d = 2.0 * depth - 1.0; + + float zview = -WinMatrix[3][2] / (d + WinMatrix[2][2]); + + return zview * (viewvecs[0].xyz + vec3(uvcoords, 0.0) * viewvecs[1].xyz); + } + else { + /* Orthographic */ + vec3 offset = vec3(uvcoords, depth); + + return viewvecs[0].xyz + offset * viewvecs[1].xyz; + } +} + +/* forward declartion */ +void ssao_factors( + in float depth, in vec3 normal, in vec3 position, in vec2 screenco, + out float cavities, out float edges); + + +void main() +{ + vec2 screenco = vec2(gl_FragCoord.xy) * invertedViewportSize; + ivec2 texel = ivec2(gl_FragCoord.xy); + + float depth = texelFetch(depthBuffer, texel, 0).x; + vec3 position = get_view_space_from_depth(screenco, depth); + + vec4 diffuse_color = texelFetch(colorBuffer, texel, 0); + vec3 normal_viewport = normal_decode(texelFetch(normalBuffer, texel, 0).rg); + if (diffuse_color.a == 0.0) { + normal_viewport = -normal_viewport; + } + + float cavity = 0.0, edges = 0.0; + ssao_factors(depth, normal_viewport, position, screenco, cavity, edges); + + fragColor = vec4(cavity, edges, 0.0, 1.0); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_cavity_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_cavity_lib.glsl new file mode 100644 index 00000000000..da0198ab2e7 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_cavity_lib.glsl @@ -0,0 +1,79 @@ + + +/* from The Alchemy screen-space ambient obscurance algorithm + * http://graphics.cs.williams.edu/papers/AlchemyHPG11/VV11AlchemyAO.pdf */ + +void ssao_factors( + in float depth, in vec3 normal, in vec3 position, in vec2 screenco, + out float cavities, out float edges) +{ + cavities = edges = 0.0; + /* early out if there is no need for SSAO */ + if (ssao_factor_cavity == 0.0 && ssao_factor_edge == 0.0) + return; + + /* take the normalized ray direction here */ + vec3 noise = texture(ssao_jitter, screenco.xy * jitter_tilling).rgb; + + /* find the offset in screen space by multiplying a point + * in camera space at the depth of the point by the projection matrix. */ + vec2 offset; + float homcoord = WinMatrix[2][3] * position.z + WinMatrix[3][3]; + offset.x = WinMatrix[0][0] * ssao_distance / homcoord; + offset.y = WinMatrix[1][1] * ssao_distance / homcoord; + /* convert from -1.0...1.0 range to 0.0..1.0 for easy use with texture coordinates */ + offset *= 0.5; + + int num_samples = int(ssao_samples_num); + + /* Note. Putting noise usage here to put some ALU after texture fetch. */ + vec2 rotX = noise.rg; + vec2 rotY = vec2(-rotX.y, rotX.x); + + for (int x = 0; x < num_samples && x < 500; x++) { + /* ssao_samples[x].xy is sample direction (normalized). + * ssao_samples[x].z is sample distance from disk center. */ + + /* Rotate with random direction to get jittered result. */ + vec2 dir_jittered = vec2(dot(ssao_samples[x].xy, rotX), dot(ssao_samples[x].xy, rotY)); + dir_jittered.xy *= ssao_samples[x].z + noise.b; + + vec2 uvcoords = screenco.xy + dir_jittered * offset; + + if (uvcoords.x > 1.0 || uvcoords.x < 0.0 || uvcoords.y > 1.0 || uvcoords.y < 0.0) + continue; + + float depth_new = texture(depthBuffer, uvcoords).r; + + /* Handle Background case */ + bool is_background = (depth_new == 1.0); + + /* This trick provide good edge effect even if no neighboor is found. */ + vec3 pos_new = get_view_space_from_depth(uvcoords, (is_background) ? depth : depth_new); + + if (is_background) + pos_new.z -= ssao_distance; + + vec3 dir = pos_new - position; + float len = length(dir); + float f_cavities = dot(dir, normal); + float f_edge = -f_cavities; + float f_bias = 0.05 * len + 0.0001; + + float attenuation = 1.0 / (len * (1.0 + len * len * ssao_attenuation)); + + /* use minor bias here to avoid self shadowing */ + if (f_cavities > -f_bias) + cavities += f_cavities * attenuation; + + if (f_edge > f_bias) + edges += f_edge * attenuation; + } + + cavities /= ssao_samples_num; + edges /= ssao_samples_num; + + /* don't let cavity wash out the surface appearance */ + cavities = clamp(cavities * ssao_factor_cavity, 0.0, 1.0); + edges = edges * ssao_factor_edge; +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_checkerboard_depth_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_checkerboard_depth_frag.glsl new file mode 100644 index 00000000000..7027543f5a9 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_checkerboard_depth_frag.glsl @@ -0,0 +1,37 @@ + +/* 4x4 bayer matrix. */ +#define P(x) ((x + 0.5) * (1.0 / 16.0)) +const vec4 dither_mat[4] = vec4[4]( + vec4( P(0.0), P(8.0), P(2.0), P(10.0)), + vec4(P(12.0), P(4.0), P(14.0), P(6.0)), + vec4( P(3.0), P(11.0), P(1.0), P(9.0)), + vec4(P(15.0), P(7.0), P(13.0), P(5.0)) +); + +uniform float threshold = 0.5; + +/* Noise dithering pattern + * 0 - Bayer matrix + * 1 - Interlieved gradient noise + */ +#define NOISE 1 + +void main() +{ +#if NOISE == 0 + ivec2 tx = ivec2(gl_FragCoord.xy) % 4; + float noise = dither_mat[tx.x][tx.y]; +#elif NOISE == 1 + /* Interlieved gradient noise by Jorge Jimenez + * http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare */ + float noise = fract(52.9829189 * fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y)); +#else +#error +#endif + + if (noise > threshold) { + discard; + } else { + gl_FragDepth = 1.0; + } +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_common_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_common_lib.glsl new file mode 100644 index 00000000000..c56e02e72d6 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_common_lib.glsl @@ -0,0 +1,121 @@ +#define NO_OBJECT_ID uint(0) +#define EPSILON 0.00001 +#define M_PI 3.14159265358979323846 + +/* 4x4 bayer matrix prepared for 8bit UNORM precision error. */ +#define P(x) (((x + 0.5) * (1.0 / 16.0) - 0.5) * (1.0 / 255.0)) +const vec4 dither_mat4x4[4] = vec4[4]( + vec4( P(0.0), P(8.0), P(2.0), P(10.0)), + vec4(P(12.0), P(4.0), P(14.0), P(6.0)), + vec4( P(3.0), P(11.0), P(1.0), P(9.0)), + vec4(P(15.0), P(7.0), P(13.0), P(5.0)) +); + +float bayer_dither_noise() { + ivec2 tx1 = ivec2(gl_FragCoord.xy) % 4; + ivec2 tx2 = ivec2(gl_FragCoord.xy) % 2; + return dither_mat4x4[tx1.x][tx1.y]; +} + +/* From http://aras-p.info/texts/CompactNormalStorage.html + * Using Method #4: Spheremap Transform */ +vec3 normal_decode(vec2 enc) +{ + vec2 fenc = enc.xy * 4.0 - 2.0; + float f = dot(fenc, fenc); + float g = sqrt(1.0 - f / 4.0); + vec3 n; + n.xy = fenc*g; + n.z = 1 - f / 2; + return n; +} + +/* From http://aras-p.info/texts/CompactNormalStorage.html + * Using Method #4: Spheremap Transform */ +vec2 normal_encode(vec3 n) +{ + float p = sqrt(n.z * 8.0 + 8.0); + return vec2(n.xy / p + 0.5); +} + +void fresnel(vec3 I, vec3 N, float ior, out float kr) +{ + float cosi = clamp(dot(I, N), -1.0, 1.0); + float etai = 1.0; + float etat = ior; + if (cosi > 0) { + etat = 1.0; + etai = ior; + } + + // Compute sini using Snell's law + float sint = etai / etat * sqrt(max(0.0, 1.0 - cosi * cosi)); + // Total internal reflection + if (sint >= 1) { + kr = 1; + } + else { + float cost = sqrt(max(0.0, 1.0 - sint * sint)); + cosi = abs(cosi); + float Rs = ((etat * cosi) - (etai * cost)) / ((etat * cosi) + (etai * cost)); + float Rp = ((etai * cosi) - (etat * cost)) / ((etai * cosi) + (etat * cost)); + kr = (Rs * Rs + Rp * Rp) / 2; + } + // As a consequence of the conservation of energy, transmittance is given by: + // kt = 1 - kr; +} + +float calculate_transparent_weight(float z, float alpha) +{ +#if 0 + /* Eq 10 : Good for surfaces with varying opacity (like particles) */ + float a = min(1.0, alpha * 10.0) + 0.01; + float b = -gl_FragCoord.z * 0.95 + 1.0; + float w = a * a * a * 3e2 * b * b * b; +#else + /* Eq 7 put more emphasis on surfaces closer to the view. */ + // float w = 10.0 / (1e-5 + pow(abs(z) / 5.0, 2.0) + pow(abs(z) / 200.0, 6.0)); /* Eq 7 */ + // float w = 10.0 / (1e-5 + pow(abs(z) / 10.0, 3.0) + pow(abs(z) / 200.0, 6.0)); /* Eq 8 */ + // float w = 10.0 / (1e-5 + pow(abs(z) / 200.0, 4.0)); /* Eq 9 */ + /* Same as eq 7, but optimized. */ + float a = abs(z) / 5.0; + float b = abs(z) / 200.0; + b *= b; + float w = 10.0 / ((1e-5 + a * a) + b * (b * b)); /* Eq 7 */ +#endif + return alpha * clamp(w, 1e-2, 3e2); +} + +/* Special function only to be used with calculate_transparent_weight(). */ +float linear_zdepth(float depth, vec4 viewvecs[3], mat4 proj_mat) +{ + if (proj_mat[3][3] == 0.0) { + float d = 2.0 * depth - 1.0; + return -proj_mat[3][2] / (d + proj_mat[2][2]); + } + else { + /* Return depth from near plane. */ + return depth * viewvecs[1].z; + } +} + +vec3 view_vector_from_screen_uv(vec2 uv, vec4 viewvecs[3], mat4 proj_mat) +{ + return (proj_mat[3][3] == 0.0) + ? normalize(viewvecs[0].xyz + vec3(uv, 0.0) * viewvecs[1].xyz) + : vec3(0.0, 0.0, 1.0); +} + +vec2 matcap_uv_compute(vec3 I, vec3 N, bool flipped) +{ + /* Quick creation of an orthonormal basis */ + float a = 1.0 / (1.0 + I.z); + float b = -I.x * I.y * a; + vec3 b1 = vec3(1.0 - I.x * I.x * a, b, -I.x); + vec3 b2 = vec3(b, 1.0 - I.y * I.y * a, -I.y); + vec2 matcap_uv = vec2(dot(b1, N), dot(b2, N)); + if (flipped) { + matcap_uv.x = -matcap_uv.x; + } + return matcap_uv * 0.496 + 0.5; +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_data_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_data_lib.glsl new file mode 100644 index 00000000000..2d913c63b00 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_data_lib.glsl @@ -0,0 +1,23 @@ +struct LightData { + vec4 light_direction_vs; + vec4 specular_color; +}; + +struct WorldData { + vec3 spherical_harmonics_coefs[STUDIOLIGHT_SPHERICAL_HARMONICS_MAX_COMPONENTS]; + vec4 background_color_low; + vec4 background_color_high; + vec4 object_outline_color; + vec4 light_direction_vs; + LightData lights[3]; + int num_lights; + int matcap_orientation; + float background_alpha; + int pad[1]; +}; + +struct MaterialData { + vec4 diffuse_color; + vec4 specular_color; + float roughness; +}; diff --git a/source/blender/draw/engines/workbench/shaders/workbench_deferred_composite_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_deferred_composite_frag.glsl new file mode 100644 index 00000000000..c72df6b677d --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_deferred_composite_frag.glsl @@ -0,0 +1,127 @@ +out vec4 fragColor; + +uniform mat4 ProjectionMatrix; + +uniform usampler2D objectId; +uniform sampler2D colorBuffer; +uniform sampler2D specularBuffer; +uniform sampler2D normalBuffer; +/* normalBuffer contains viewport normals */ +uniform sampler2D cavityBuffer; + +uniform vec2 invertedViewportSize; +uniform vec4 viewvecs[3]; +uniform float shadowMultiplier; +uniform float lightMultiplier; +uniform float shadowShift = 0.1; +uniform mat3 normalWorldMatrix; + +#ifdef STUDIOLIGHT_ORIENTATION_VIEWNORMAL +uniform sampler2D matcapImage; +#endif + +layout(std140) uniform world_block { + WorldData world_data; +}; + +void main() +{ + ivec2 texel = ivec2(gl_FragCoord.xy); + vec2 uv_viewport = gl_FragCoord.xy * invertedViewportSize; + uint object_id = texelFetch(objectId, texel, 0).r; + +#ifndef V3D_SHADING_OBJECT_OUTLINE + if (object_id == NO_OBJECT_ID) { + fragColor = vec4(background_color(world_data, uv_viewport.y), world_data.background_alpha); + return; + } +#else /* !V3D_SHADING_OBJECT_OUTLINE */ + float object_outline = calculate_object_outline(objectId, texel, object_id); + + if (object_id == NO_OBJECT_ID) { + vec3 background = background_color(world_data, uv_viewport.y); + if (object_outline == 0.0) { + fragColor = vec4(background, world_data.background_alpha); + } + else { + fragColor = vec4(mix(world_data.object_outline_color.rgb, background, object_outline), clamp(world_data.background_alpha, 1.0, object_outline)); + } + return; + } +#endif /* !V3D_SHADING_OBJECT_OUTLINE */ + + vec4 diffuse_color = texelFetch(colorBuffer, texel, 0); + +/* Do we need normals */ +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +# ifdef WORKBENCH_ENCODE_NORMALS + vec3 normal_viewport = normal_decode(texelFetch(normalBuffer, texel, 0).rg); + if (diffuse_color.a == 0.0) { + normal_viewport = -normal_viewport; + } +# else /* WORKBENCH_ENCODE_NORMALS */ + vec3 normal_viewport = texelFetch(normalBuffer, texel, 0).rgb; +# endif /* WORKBENCH_ENCODE_NORMALS */ +#endif + + vec3 I_vs = view_vector_from_screen_uv(uv_viewport, viewvecs, ProjectionMatrix); + +#ifdef STUDIOLIGHT_ORIENTATION_VIEWNORMAL + bool flipped = world_data.matcap_orientation != 0; + vec2 matcap_uv = matcap_uv_compute(I_vs, normal_viewport, flipped); + diffuse_color = textureLod(matcapImage, matcap_uv, 0.0); +#endif + +#ifdef V3D_SHADING_SPECULAR_HIGHLIGHT + vec4 specular_data = texelFetch(specularBuffer, texel, 0); + vec3 specular_color = get_world_specular_lights(world_data, specular_data, normal_viewport, I_vs); +#else + vec3 specular_color = vec3(0.0); +#endif + +#ifdef V3D_LIGHTING_FLAT + vec3 diffuse_light = vec3(1.0); +#endif + +#ifdef V3D_LIGHTING_MATCAP + vec3 diffuse_light = texelFetch(specularBuffer, texel, 0).rgb; +#endif + +#ifdef V3D_LIGHTING_STUDIO +# ifdef STUDIOLIGHT_ORIENTATION_CAMERA + vec3 diffuse_light = get_camera_diffuse_light(world_data, normal_viewport); +# endif + +# ifdef STUDIOLIGHT_ORIENTATION_WORLD + vec3 normal_world = normalWorldMatrix * normal_viewport; + vec3 diffuse_light = get_world_diffuse_light(world_data, normal_world); +# endif +#endif + vec3 shaded_color = diffuse_light * diffuse_color.rgb + specular_color; + +#ifdef V3D_SHADING_CAVITY + vec2 cavity = texelFetch(cavityBuffer, texel, 0).rg; + shaded_color *= 1.0 - cavity.x; + shaded_color *= 1.0 + cavity.y; +#endif + +#ifdef V3D_SHADING_SHADOW + float light_factor = -dot(normal_viewport, world_data.lights[0].light_direction_vs.xyz); + /* The step function might be ok for meshes but it's + * clearly not the case for hairs. Do smoothstep in this case. */ + float shadow_mix = (diffuse_color.a == 1.0 || diffuse_color.a == 0.0) + ? step(-shadowShift, -light_factor) + : smoothstep(1.0, shadowShift, light_factor); + float light_multiplier = mix(lightMultiplier, shadowMultiplier, shadow_mix); + +#else /* V3D_SHADING_SHADOW */ + float light_multiplier = 1.0; +#endif /* V3D_SHADING_SHADOW */ + + shaded_color *= light_multiplier; + +#ifdef V3D_SHADING_OBJECT_OUTLINE + shaded_color = mix(world_data.object_outline_color.rgb, shaded_color, object_outline); +#endif /* V3D_SHADING_OBJECT_OUTLINE */ + fragColor = vec4(shaded_color, 1.0); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_effect_fxaa_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_effect_fxaa_frag.glsl new file mode 100644 index 00000000000..4ffd20c2839 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_effect_fxaa_frag.glsl @@ -0,0 +1,19 @@ + +in vec4 uvcoordsvar; + +out vec4 FragColor; + +uniform sampler2D colorBuffer; +uniform vec2 invertedViewportSize; + +void main() +{ + FragColor = FxaaPixelShader( + uvcoordsvar.st, + colorBuffer, + invertedViewportSize, + 1.0, + 0.166, + 0.0833 + ); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_forward_composite_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_forward_composite_frag.glsl new file mode 100644 index 00000000000..1d9f37274bd --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_forward_composite_frag.glsl @@ -0,0 +1,37 @@ +out vec4 fragColor; + +uniform usampler2D objectId; +uniform sampler2D transparentAccum; +uniform sampler2D transparentRevealage; +uniform vec2 invertedViewportSize; + +layout(std140) uniform world_block { + WorldData world_data; +}; + +void main() +{ + ivec2 texel = ivec2(gl_FragCoord.xy); + vec2 uv_viewport = gl_FragCoord.xy * invertedViewportSize; + uint object_id = texelFetch(objectId, texel, 0).r; + + /* Listing 4 */ + vec4 trans_accum = texelFetch(transparentAccum, texel, 0); + float trans_revealage = trans_accum.a; + trans_accum.a = texelFetch(transparentRevealage, texel, 0).r; + +#ifdef V3D_SHADING_OBJECT_OUTLINE + float outline = calculate_object_outline(objectId, texel, object_id); +#else /* V3D_SHADING_OBJECT_OUTLINE */ + float outline = 1.0; +#endif /* V3D_SHADING_OBJECT_OUTLINE */ + vec3 bg_color = background_color(world_data, uv_viewport.y); + + /* TODO: Bypass the whole shader if there is no xray pass and no outline pass. */ + vec3 trans_color = trans_accum.rgb / clamp(trans_accum.a, 1e-4, 5e4); + vec3 color = mix(trans_color, bg_color, trans_revealage); + + color = mix(world_data.object_outline_color.rgb, color, outline); + + fragColor = vec4(color, 1.0); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_forward_depth_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_forward_depth_frag.glsl new file mode 100644 index 00000000000..450cb3e680b --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_forward_depth_frag.glsl @@ -0,0 +1,8 @@ +uniform int object_id = 0; +layout(location=0) out uint objectId; + +void main() +{ + objectId = uint(object_id); +} + diff --git a/source/blender/draw/engines/workbench/shaders/workbench_forward_transparent_accum_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_forward_transparent_accum_frag.glsl new file mode 100644 index 00000000000..1b3737193b0 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_forward_transparent_accum_frag.glsl @@ -0,0 +1,83 @@ +#ifdef V3D_SHADING_TEXTURE_COLOR +uniform sampler2D image; +#endif +uniform mat4 ProjectionMatrix; +uniform mat3 normalWorldMatrix; +uniform float alpha = 0.5; +uniform vec2 invertedViewportSize; +uniform vec4 viewvecs[3]; + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +in vec3 normal_viewport; +#endif /* NORMAL_VIEWPORT_PASS_ENABLED */ +#ifdef V3D_SHADING_TEXTURE_COLOR +in vec2 uv_interp; +#endif +#ifdef STUDIOLIGHT_ORIENTATION_VIEWNORMAL +uniform sampler2D matcapImage; +#endif + +layout(std140) uniform world_block { + WorldData world_data; +}; + +layout(std140) uniform material_block { + MaterialData material_data; +}; + +layout(location=0) out vec4 transparentAccum; +layout(location=1) out float revealageAccum; /* revealage actually stored in transparentAccum.a */ + +void main() +{ + vec4 diffuse_color; + vec3 diffuse_light = vec3(1.0); + +#ifdef V3D_SHADING_TEXTURE_COLOR + diffuse_color = texture(image, uv_interp); +#else + diffuse_color = material_data.diffuse_color; +#endif /* V3D_SHADING_TEXTURE_COLOR */ + + vec2 uv_viewport = gl_FragCoord.xy * invertedViewportSize; + vec3 I_vs = view_vector_from_screen_uv(uv_viewport, viewvecs, ProjectionMatrix); + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED + vec3 nor = normalize(normal_viewport); +#endif + +#ifdef V3D_LIGHTING_MATCAP + bool flipped = world_data.matcap_orientation != 0; + vec2 matcap_uv = matcap_uv_compute(I_vs, nor, flipped); + diffuse_light = texture(matcapImage, matcap_uv).rgb; +#endif + +#ifdef V3D_SHADING_SPECULAR_HIGHLIGHT + vec3 specular_color = get_world_specular_lights(world_data, vec4(material_data.specular_color.rgb, material_data.roughness), nor, I_vs); +#else + vec3 specular_color = vec3(0.0); +#endif + +#ifdef V3D_LIGHTING_STUDIO +# ifdef STUDIOLIGHT_ORIENTATION_CAMERA + diffuse_light = get_camera_diffuse_light(world_data, nor); +# endif +# ifdef STUDIOLIGHT_ORIENTATION_WORLD + vec3 normal_world = normalWorldMatrix * nor; + diffuse_light = get_world_diffuse_light(world_data, normal_world); +# endif +#endif + + vec3 shaded_color = diffuse_light * diffuse_color.rgb + specular_color; + + /* Based on : + * McGuire and Bavoil, Weighted Blended Order-Independent Transparency, Journal of + * Computer Graphics Techniques (JCGT), vol. 2, no. 2, 122–141, 2013 + */ + /* Listing 4 */ + float z = linear_zdepth(gl_FragCoord.z, viewvecs, ProjectionMatrix); + float weight = calculate_transparent_weight(z, alpha); + transparentAccum = vec4(shaded_color * weight, alpha); + revealageAccum = weight; +} + diff --git a/source/blender/draw/engines/workbench/shaders/workbench_object_outline_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_object_outline_lib.glsl new file mode 100644 index 00000000000..3e925ba023f --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_object_outline_lib.glsl @@ -0,0 +1,12 @@ +#define OBJECT_OUTLINE_OFFSET 1 + +float calculate_object_outline(usampler2D objectId, ivec2 texel, uint object_id) +{ + uvec4 oid_offset = uvec4( + texelFetchOffset(objectId, texel, 0, ivec2(0, OBJECT_OUTLINE_OFFSET)).r, + texelFetchOffset(objectId, texel, 0, ivec2(0, -OBJECT_OUTLINE_OFFSET)).r, + texelFetchOffset(objectId, texel, 0, ivec2(-OBJECT_OUTLINE_OFFSET, 0)).r, + texelFetchOffset(objectId, texel, 0, ivec2( OBJECT_OUTLINE_OFFSET, 0)).r); + + return dot(vec4(equal(uvec4(object_id), oid_offset)), vec4(0.25)); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_prepass_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_prepass_frag.glsl new file mode 100644 index 00000000000..6aeb912377c --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_prepass_frag.glsl @@ -0,0 +1,76 @@ +uniform int object_id = 0; + +layout(std140) uniform material_block { + MaterialData material_data; +}; + +#ifdef V3D_SHADING_TEXTURE_COLOR +uniform sampler2D image; +#endif + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +in vec3 normal_viewport; +#endif /* NORMAL_VIEWPORT_PASS_ENABLED */ + +#ifdef V3D_SHADING_TEXTURE_COLOR +in vec2 uv_interp; +#endif /* V3D_SHADING_TEXTURE_COLOR */ + +#ifdef HAIR_SHADER +flat in float hair_rand; +#endif + +layout(location=0) out uint objectId; +layout(location=1) out vec4 diffuseColor; +layout(location=2) out vec4 specularColor; +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +# ifdef WORKBENCH_ENCODE_NORMALS +layout(location=3) out vec2 normalViewport; +# else /* WORKBENCH_ENCODE_NORMALS */ +layout(location=3) out vec3 normalViewport; +# endif /* WORKBENCH_ENCODE_NORMALS */ +#endif /* NORMAL_VIEWPORT_PASS_ENABLED */ + +void main() +{ + objectId = uint(object_id); + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED + vec3 n = (gl_FrontFacing) ? normal_viewport : -normal_viewport; + n = normalize(n); +#endif + +#ifdef V3D_SHADING_TEXTURE_COLOR + diffuseColor = texture(image, uv_interp); +#else + diffuseColor = vec4(material_data.diffuse_color.rgb, 0.0); +# ifdef STUDIOLIGHT_ORIENTATION_VIEWNORMAL + specularColor = vec4(material_data.diffuse_color.rgb, 0.0); + +# endif +#endif /* V3D_SHADING_TEXTURE_COLOR */ + +#ifdef HAIR_SHADER + float hair_color_variation = hair_rand * 0.1; + diffuseColor.rgb = clamp(diffuseColor.rgb - hair_color_variation, 0.0, 1.0); +#endif + +#ifdef V3D_SHADING_SPECULAR_HIGHLIGHT + specularColor = vec4(material_data.specular_color.rgb, material_data.roughness); +# ifdef HAIR_SHADER + specularColor.rgb = clamp(specularColor.rgb - hair_color_variation, 0.0, 1.0); +# endif +#endif + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +# ifdef WORKBENCH_ENCODE_NORMALS + diffuseColor.a = float(gl_FrontFacing); + normalViewport = normal_encode(n); +# else /* WORKBENCH_ENCODE_NORMALS */ + normalViewport = n; +# endif /* WORKBENCH_ENCODE_NORMALS */ +# ifdef HAIR_SHADER + diffuseColor.a = 0.5; +# endif +#endif /* NORMAL_VIEWPORT_PASS_ENABLED */ +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_prepass_vert.glsl b/source/blender/draw/engines/workbench/shaders/workbench_prepass_vert.glsl new file mode 100644 index 00000000000..66b529fcf5e --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_prepass_vert.glsl @@ -0,0 +1,68 @@ +uniform mat4 ModelViewProjectionMatrix; +uniform mat4 ProjectionMatrix; +uniform mat4 ViewProjectionMatrix; +uniform mat4 ViewMatrixInverse; +uniform mat3 NormalMatrix; + +#ifndef HAIR_SHADER +in vec3 pos; +in vec3 nor; +in vec2 uv; +#else /* HAIR_SHADER */ +# ifdef V3D_SHADING_TEXTURE_COLOR +uniform samplerBuffer u; /* active texture layer */ +# endif +flat out float hair_rand; +#endif /* HAIR_SHADER */ + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED +out vec3 normal_viewport; +#endif + +#ifdef V3D_SHADING_TEXTURE_COLOR +out vec2 uv_interp; +#endif + +/* From http://libnoise.sourceforge.net/noisegen/index.html */ +float integer_noise(int n) +{ + n = (n >> 13) ^ n; + int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff; + return (float(nn) / 1073741824.0); +} + +void main() +{ +#ifdef HAIR_SHADER +# ifdef V3D_SHADING_TEXTURE_COLOR + vec2 uv = hair_get_customdata_vec2(u); +# endif + float time, thick_time, thickness; + vec3 pos, tan, binor; + hair_get_pos_tan_binor_time( + (ProjectionMatrix[3][3] == 0.0), + ViewMatrixInverse[3].xyz, ViewMatrixInverse[2].xyz, + pos, tan, binor, time, thickness, thick_time); + /* To "simulate" anisotropic shading, randomize hair normal per strand. */ + hair_rand = integer_noise(hair_get_strand_id()); + tan = normalize(tan); + vec3 nor = normalize(cross(binor, tan)); + nor = normalize(mix(nor, -tan, hair_rand * 0.10)); + float cos_theta = (hair_rand*2.0 - 1.0) * 0.20; + float sin_theta = sqrt(max(0.0, 1.0f - cos_theta*cos_theta)); + nor = nor * sin_theta + binor * cos_theta; + gl_Position = ViewProjectionMatrix * vec4(pos, 1.0); +#else + gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0); +#endif +#ifdef V3D_SHADING_TEXTURE_COLOR + uv_interp = uv; +#endif + +#ifdef NORMAL_VIEWPORT_PASS_ENABLED + normal_viewport = NormalMatrix * nor; +# ifndef HAIR_SHADER + normal_viewport = normalize(normal_viewport); +# endif +#endif +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_shadow_caps_geom.glsl b/source/blender/draw/engines/workbench/shaders/workbench_shadow_caps_geom.glsl new file mode 100644 index 00000000000..948392bd8ee --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_shadow_caps_geom.glsl @@ -0,0 +1,85 @@ +#extension GL_ARB_gpu_shader5 : enable + +#ifdef GL_ARB_gpu_shader5 +#define USE_INVOC_EXT +#endif + +#ifdef DOUBLE_MANIFOLD +# ifdef USE_INVOC_EXT +# define invoc_ct 2 +# else +# define vert_ct 6 +# endif +#else +# ifdef USE_INVOC_EXT +# define invoc_ct 2 +# else +# define vert_ct 6 +# endif +#endif + +#ifdef USE_INVOC_EXT +layout(triangles, invocations = invoc_ct) in; +layout(triangle_strip, max_vertices = 3) out; +#else +layout(triangles) in; +layout(triangle_strip, max_vertices = vert_ct) out; +#endif + +uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57); + +in VertexData { + vec3 pos; /* local position */ + vec4 frontPosition; /* final ndc position */ + vec4 backPosition; +} vData[]; + +vec4 get_pos(int v, bool backface) +{ + return (backface) ? vData[v].backPosition : vData[v].frontPosition; +} + +void emit_cap(const bool front, bool reversed) +{ + if (front) { + gl_Position = vData[0].frontPosition; EmitVertex(); + gl_Position = vData[reversed ? 2 : 1].frontPosition; EmitVertex(); + gl_Position = vData[reversed ? 1 : 2].frontPosition; EmitVertex(); + } + else { + gl_Position = vData[0].backPosition; EmitVertex(); + gl_Position = vData[reversed ? 1 : 2].backPosition; EmitVertex(); + gl_Position = vData[reversed ? 2 : 1].backPosition; EmitVertex(); + } + EndPrimitive(); +} + +void main() +{ + vec3 v10 = vData[0].pos - vData[1].pos; + vec3 v12 = vData[2].pos - vData[1].pos; + + vec3 n = cross(v12, v10); + float facing = dot(n, lightDirection); + + bool backface = facing > 0.0; + +#ifdef DOUBLE_MANIFOLD + /* In case of non manifold geom, we only increase/decrease + * the stencil buffer by one but do every faces as they were facing the light. */ + bool invert = backface; +#else + const bool invert = false; + if (!backface) { +#endif +#ifdef USE_INVOC_EXT + bool do_front = (gl_InvocationID & 1) == 0; + emit_cap(do_front, invert); +#else + emit_cap(true, invert); + emit_cap(false, invert); +#endif +#ifndef DOUBLE_MANIFOLD + } +#endif +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_shadow_debug_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_shadow_debug_frag.glsl new file mode 100644 index 00000000000..ceb33e77f2b --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_shadow_debug_frag.glsl @@ -0,0 +1,14 @@ + +out vec4 fragColor; + +void main() +{ + const float intensity = 0.25; +#ifdef SHADOW_PASS + fragColor = vec4((gl_FrontFacing) ? vec3(intensity, -intensity, 0.0) + : vec3(-intensity, intensity, 0.0), 1.0); +#else + fragColor = vec4((gl_FrontFacing) ? vec3(intensity, intensity, -intensity) + : vec3(-intensity, -intensity, intensity), 1.0); +#endif +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_shadow_geom.glsl b/source/blender/draw/engines/workbench/shaders/workbench_shadow_geom.glsl new file mode 100644 index 00000000000..5a31aa34932 --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_shadow_geom.glsl @@ -0,0 +1,118 @@ +#extension GL_ARB_gpu_shader5 : enable + +#ifdef GL_ARB_gpu_shader5 +#define USE_INVOC_EXT +#endif + +#ifdef DOUBLE_MANIFOLD +# ifdef USE_INVOC_EXT +# define invoc_ct 2 +# else +# define vert_ct 8 +# endif +#else +# ifdef USE_INVOC_EXT +# define invoc_ct 1 +# else +# define vert_ct 4 +# endif +#endif + +#ifdef USE_INVOC_EXT +layout(lines_adjacency, invocations = invoc_ct) in; +layout(triangle_strip, max_vertices = 4) out; +#else +layout(lines_adjacency) in; +layout(triangle_strip, max_vertices = vert_ct) out; +#endif + +uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57); + +in VertexData { + vec3 pos; /* local position */ + vec4 frontPosition; /* final ndc position */ + vec4 backPosition; +} vData[]; + +#define DEGENERATE_THRESHOLD 1e-12 + +#define len_sqr(a) dot(a, a) + +void extrude_edge(bool invert) +{ + /* Reverse order if backfacing the light. */ + ivec2 idx = (invert) ? ivec2(1, 2) : ivec2(2, 1); + gl_Position = vData[idx.x].frontPosition; EmitVertex(); + gl_Position = vData[idx.y].frontPosition; EmitVertex(); + gl_Position = vData[idx.x].backPosition; EmitVertex(); + gl_Position = vData[idx.y].backPosition; EmitVertex(); + EndPrimitive(); +} + +void main() +{ + vec3 v10 = vData[0].pos - vData[1].pos; + vec3 v12 = vData[2].pos - vData[1].pos; + vec3 v13 = vData[3].pos - vData[1].pos; + +#ifdef DEGENERATE_THRESHOLD + vec3 v20 = vData[0].pos - vData[2].pos; + vec3 v23 = vData[3].pos - vData[2].pos; + + vec4 edges_lensqr = vec4(len_sqr(v10), len_sqr(v13), len_sqr(v20), len_sqr(v23)); + bvec4 degen_edges = lessThan(edges_lensqr, vec4(DEGENERATE_THRESHOLD)); + + /* Both triangles are degenerate, abort. */ + if (any(degen_edges.xz) && any(degen_edges.yw)) + return; +#endif + + vec3 n1 = cross(v12, v10); + vec3 n2 = cross(v13, v12); + vec2 facing = vec2(dot(n1, lightDirection), + dot(n2, lightDirection)); + + /* WATCH: maybe unpredictable in some cases. */ + bool is_manifold = any(notEqual(vData[0].pos, vData[3].pos)); + + bvec2 backface = greaterThan(facing, vec2(0.0)); + +#ifdef DEGENERATE_THRESHOLD +# ifndef DOUBLE_MANIFOLD + /* If the mesh is known to be manifold and we don't use double count, + * only create an quad if the we encounter a facing geom. */ + if ((any(degen_edges.xz) && backface.y) || + (any(degen_edges.yw) && backface.x)) + return; +# endif + + /* If one of the 2 triangles is degenerate, replace edge by a non-manifold one. */ + backface.x = (any(degen_edges.xz)) ? !backface.y : backface.x; + backface.y = (any(degen_edges.yw)) ? !backface.x : backface.y; + is_manifold = (any(degen_edges)) ? false : is_manifold; +#endif + + /* If both faces face the same direction it's not an outline edge. */ + if (backface.x == backface.y) + return; + +#ifdef USE_INVOC_EXT + if (gl_InvocationID == 0) { + extrude_edge(backface.x); + } + else if (is_manifold) { +# ifdef DOUBLE_MANIFOLD + /* Increment/Decrement twice for manifold edges. */ + extrude_edge(backface.x); +# endif + } +#else + extrude_edge(backface.x); + if (is_manifold) { +# ifdef DOUBLE_MANIFOLD + /* Increment/Decrement twice for manifold edges. */ + extrude_edge(backface.x); +# endif + } +#endif +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_shadow_vert.glsl b/source/blender/draw/engines/workbench/shaders/workbench_shadow_vert.glsl new file mode 100644 index 00000000000..50a721f948f --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_shadow_vert.glsl @@ -0,0 +1,21 @@ +#define INFINITE 1000.0 + +uniform mat4 ModelViewProjectionMatrix; + +uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57); +uniform float lightDistance = 1e4; + +in vec3 pos; + +out VertexData { + vec3 pos; /* local position */ + vec4 frontPosition; /* final ndc position */ + vec4 backPosition; +} vData; + +void main() +{ + vData.pos = pos; + vData.frontPosition = ModelViewProjectionMatrix * vec4(pos, 1.0); + vData.backPosition = ModelViewProjectionMatrix * vec4(pos + lightDirection * lightDistance, 1.0); +} diff --git a/source/blender/draw/engines/workbench/shaders/workbench_world_light_lib.glsl b/source/blender/draw/engines/workbench/shaders/workbench_world_light_lib.glsl new file mode 100644 index 00000000000..b13c4f1b43b --- /dev/null +++ b/source/blender/draw/engines/workbench/shaders/workbench_world_light_lib.glsl @@ -0,0 +1,74 @@ +#define BLINN + +vec3 spherical_harmonics(vec3 N, vec3 spherical_harmonics_coefs[STUDIOLIGHT_SPHERICAL_HARMONICS_MAX_COMPONENTS]) +{ + vec3 sh = vec3(0.0); + + sh += 0.282095 * spherical_harmonics_coefs[0]; + +#if STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL > 0 + sh += -0.488603 * N.z * spherical_harmonics_coefs[1]; + sh += 0.488603 * N.y * spherical_harmonics_coefs[2]; + sh += -0.488603 * N.x * spherical_harmonics_coefs[3]; +#endif + +#if STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL > 1 + sh += 1.092548 * N.x * N.z * spherical_harmonics_coefs[4]; + sh += -1.092548 * N.z * N.y * spherical_harmonics_coefs[5]; + sh += 0.315392 * (3.0 * N.y * N.y - 1.0) * spherical_harmonics_coefs[6]; + sh += -1.092548 * N.x * N.y * spherical_harmonics_coefs[7]; + sh += 0.546274 * (N.x * N.x - N.z * N.z) * spherical_harmonics_coefs[8]; +#endif + + return sh; +} + +vec3 get_world_diffuse_light(WorldData world_data, vec3 N) +{ + return (spherical_harmonics(vec3(N.x, N.y, -N.z), world_data.spherical_harmonics_coefs)); +} + +vec3 get_camera_diffuse_light(WorldData world_data, vec3 N) +{ + return (spherical_harmonics(vec3(N.x, -N.z, -N.y), world_data.spherical_harmonics_coefs)); +} + +/* N And I are in View Space. */ +vec3 get_world_specular_light(vec4 specular_data, LightData light_data, vec3 N, vec3 I) +{ +#ifdef V3D_SHADING_SPECULAR_HIGHLIGHT + vec3 specular_light = specular_data.rgb * light_data.specular_color.rgb * light_data.specular_color.a; + + float shininess = exp2(10*(1.0-specular_data.a) + 1); + +# ifdef BLINN + float normalization_factor = (shininess + 8) / (8 * M_PI); + vec3 L = -light_data.light_direction_vs.xyz; + vec3 halfDir = normalize(L + I); + float specAngle = max(dot(halfDir, N), 0.0); + float NL = max(dot(L, N), 0.0); + float specular_influence = pow(specAngle, shininess) * NL * normalization_factor; + +# else + vec3 reflection_vector = reflect(I, N); + float specAngle = max(dot(light_data.light_direction_vs.xyz, reflection_vector), 0.0); + float specular_influence = pow(specAngle, shininess); +# endif + + vec3 specular_color = specular_light * specular_influence; + +#else /* V3D_SHADING_SPECULAR_HIGHLIGHT */ + vec3 specular_color = vec3(0.0); +#endif /* V3D_SHADING_SPECULAR_HIGHLIGHT */ + return specular_color; +} + +vec3 get_world_specular_lights(WorldData world_data, vec4 specular_data, vec3 N, vec3 I) +{ + vec3 specular_light = vec3(0.0); + specular_light += get_world_specular_light(specular_data, world_data.lights[0], N, I); + for (int i = 0 ; i < world_data.num_lights ; i ++) { + specular_light += get_world_specular_light(specular_data, world_data.lights[i], N, I); + } + return specular_light; +} diff --git a/source/blender/draw/engines/workbench/solid_mode.c b/source/blender/draw/engines/workbench/solid_mode.c new file mode 100644 index 00000000000..1e49d1ae573 --- /dev/null +++ b/source/blender/draw/engines/workbench/solid_mode.c @@ -0,0 +1,96 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file solid_mode.c + * \ingroup draw_engine + * + * Simple engine for drawing color and/or depth. + * When we only need simple studio shaders. + */ + +#include "DRW_render.h" + +#include "GPU_shader.h" + +#include "workbench_private.h" + +/* Functions */ + +static void workbench_solid_engine_init(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_deferred_engine_init(data); +} + +static void workbench_solid_cache_init(void *vedata) +{ + + WORKBENCH_Data *data = vedata; + workbench_deferred_cache_init(data); +} + +static void workbench_solid_cache_populate(void *vedata, Object *ob) +{ + WORKBENCH_Data *data = vedata; + workbench_deferred_solid_cache_populate(data, ob); +} + +static void workbench_solid_cache_finish(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_deferred_cache_finish(data); +} + +static void workbench_solid_draw_background(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_deferred_draw_background(data); +} + +static void workbench_solid_draw_scene(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_deferred_draw_scene(data); +} + +static void workbench_solid_engine_free(void) +{ + workbench_deferred_engine_free(); +} + +static const DrawEngineDataSize workbench_data_size = DRW_VIEWPORT_DATA_SIZE(WORKBENCH_Data); + +DrawEngineType draw_engine_workbench_solid = { + NULL, NULL, + N_("Workbench"), + &workbench_data_size, + &workbench_solid_engine_init, + &workbench_solid_engine_free, + &workbench_solid_cache_init, + &workbench_solid_cache_populate, + &workbench_solid_cache_finish, + &workbench_solid_draw_background, + &workbench_solid_draw_scene, + NULL, + NULL, + NULL, +}; + diff --git a/source/blender/draw/engines/workbench/transparent_mode.c b/source/blender/draw/engines/workbench/transparent_mode.c new file mode 100644 index 00000000000..c5d3db4b390 --- /dev/null +++ b/source/blender/draw/engines/workbench/transparent_mode.c @@ -0,0 +1,96 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file transparent_mode.c + * \ingroup draw_engine + * + * Simple engine for drawing color and/or depth. + * When we only need simple studio shaders. + */ + +#include "DRW_render.h" + +#include "GPU_shader.h" + +#include "workbench_private.h" + +/* Functions */ + +static void workbench_transparent_engine_init(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_forward_engine_init(data); +} + +static void workbench_transparent_cache_init(void *vedata) +{ + + WORKBENCH_Data *data = vedata; + workbench_forward_cache_init(data); +} + +static void workbench_transparent_cache_populate(void *vedata, Object *ob) +{ + WORKBENCH_Data *data = vedata; + workbench_forward_cache_populate(data, ob); +} + +static void workbench_transparent_cache_finish(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_forward_cache_finish(data); +} + +static void workbench_transparent_draw_background(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_forward_draw_background(data); +} + +static void workbench_transparent_draw_scene(void *vedata) +{ + WORKBENCH_Data *data = vedata; + workbench_forward_draw_scene(data); +} + +static void workbench_transparent_engine_free(void) +{ + workbench_forward_engine_free(); +} + +static const DrawEngineDataSize workbench_data_size = DRW_VIEWPORT_DATA_SIZE(WORKBENCH_Data); + +DrawEngineType draw_engine_workbench_transparent = { + NULL, NULL, + N_("Workbench"), + &workbench_data_size, + &workbench_transparent_engine_init, + &workbench_transparent_engine_free, + &workbench_transparent_cache_init, + &workbench_transparent_cache_populate, + &workbench_transparent_cache_finish, + &workbench_transparent_draw_background, + &workbench_transparent_draw_scene, + NULL, + NULL, + NULL, +}; + diff --git a/source/blender/draw/engines/workbench/workbench_data.c b/source/blender/draw/engines/workbench/workbench_data.c new file mode 100644 index 00000000000..d544e7614ab --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_data.c @@ -0,0 +1,170 @@ +#include "workbench_private.h" + +#include "DNA_userdef_types.h" + +#include "UI_resources.h" + + +void workbench_private_data_init(WORKBENCH_PrivateData *wpd) +{ + const DRWContextState *draw_ctx = DRW_context_state_get(); + const Scene *scene = draw_ctx->scene; + wpd->material_hash = BLI_ghash_ptr_new(__func__); + wpd->user_preferences = &U; + + View3D *v3d = draw_ctx->v3d; + if (v3d) { + wpd->shading = v3d->shading; + if (wpd->shading.light == V3D_LIGHTING_MATCAP) { + wpd->studio_light = BKE_studiolight_find( + wpd->shading.matcap, STUDIOLIGHT_ORIENTATION_VIEWNORMAL); + } + else { + wpd->studio_light = BKE_studiolight_find( + wpd->shading.studio_light, STUDIOLIGHT_ORIENTATION_CAMERA | STUDIOLIGHT_ORIENTATION_WORLD); + } + } + else { + memset(&wpd->shading, 0, sizeof(wpd->shading)); + wpd->shading.light = V3D_LIGHTING_STUDIO; + wpd->shading.shadow_intensity = 0.5; + copy_v3_fl(wpd->shading.single_color, 0.8f); + wpd->studio_light = BKE_studiolight_find_first(STUDIOLIGHT_INTERNAL); + } + wpd->shadow_multiplier = 1.0 - wpd->shading.shadow_intensity; + + WORKBENCH_UBO_World *wd = &wpd->world_data; + wd->matcap_orientation = (wpd->shading.flag & V3D_SHADING_MATCAP_FLIP_X) > 0; + wd->background_alpha = 1.0f; + + if ((v3d->flag3 & V3D_SHOW_WORLD) && + (scene->world != NULL)) + { + copy_v3_v3(wd->background_color_low, &scene->world->horr); + copy_v3_v3(wd->background_color_high, &scene->world->horr); + } + else { + UI_GetThemeColor3fv(UI_GetThemeValue(TH_SHOW_BACK_GRAD) ? TH_LOW_GRAD : TH_HIGH_GRAD, wd->background_color_low); + UI_GetThemeColor3fv(TH_HIGH_GRAD, wd->background_color_high); + + /* XXX: Really quick conversion to avoid washed out background. + * Needs to be adressed properly (color managed using ocio). */ + srgb_to_linearrgb_v3_v3(wd->background_color_high, wd->background_color_high); + srgb_to_linearrgb_v3_v3(wd->background_color_low, wd->background_color_low); + } + + studiolight_update_world(wpd->studio_light, wd); + + copy_v3_v3(wd->object_outline_color, wpd->shading.object_outline_color); + wd->object_outline_color[3] = 1.0f; + + wpd->world_ubo = DRW_uniformbuffer_create(sizeof(WORKBENCH_UBO_World), &wpd->world_data); + + /* Cavity settings */ + { + const int ssao_samples = scene->display.matcap_ssao_samples; + + float invproj[4][4]; + float dfdyfacs[2]; + const bool is_persp = DRW_viewport_is_persp_get(); + /* view vectors for the corners of the view frustum. + * Can be used to recreate the world space position easily */ + float viewvecs[3][4] = { + {-1.0f, -1.0f, -1.0f, 1.0f}, + {1.0f, -1.0f, -1.0f, 1.0f}, + {-1.0f, 1.0f, -1.0f, 1.0f} + }; + int i; + const float *size = DRW_viewport_size_get(); + + DRW_state_dfdy_factors_get(dfdyfacs); + + wpd->ssao_params[0] = ssao_samples; + wpd->ssao_params[1] = size[0] / 64.0; + wpd->ssao_params[2] = size[1] / 64.0; + wpd->ssao_params[3] = dfdyfacs[1]; /* dfdy sign for offscreen */ + + /* distance, factor, factor, attenuation */ + copy_v4_fl4(wpd->ssao_settings, scene->display.matcap_ssao_distance, wpd->shading.cavity_valley_factor, wpd->shading.cavity_ridge_factor, scene->display.matcap_ssao_attenuation); + + /* invert the view matrix */ + DRW_viewport_matrix_get(wpd->winmat, DRW_MAT_WIN); + invert_m4_m4(invproj, wpd->winmat); + + /* convert the view vectors to view space */ + for (i = 0; i < 3; i++) { + mul_m4_v4(invproj, viewvecs[i]); + /* normalized trick see: + * http://www.derschmale.com/2014/01/26/reconstructing-positions-from-the-depth-buffer */ + mul_v3_fl(viewvecs[i], 1.0f / viewvecs[i][3]); + if (is_persp) + mul_v3_fl(viewvecs[i], 1.0f / viewvecs[i][2]); + viewvecs[i][3] = 1.0; + + copy_v4_v4(wpd->viewvecs[i], viewvecs[i]); + } + + /* we need to store the differences */ + wpd->viewvecs[1][0] -= wpd->viewvecs[0][0]; + wpd->viewvecs[1][1] = wpd->viewvecs[2][1] - wpd->viewvecs[0][1]; + + /* calculate a depth offset as well */ + if (!is_persp) { + float vec_far[] = {-1.0f, -1.0f, 1.0f, 1.0f}; + mul_m4_v4(invproj, vec_far); + mul_v3_fl(vec_far, 1.0f / vec_far[3]); + wpd->viewvecs[1][2] = vec_far[2] - wpd->viewvecs[0][2]; + } + } +} + +void workbench_private_data_get_light_direction(WORKBENCH_PrivateData *wpd, float light_direction[3]) +{ + const DRWContextState *draw_ctx = DRW_context_state_get(); + Scene *scene = draw_ctx->scene; + WORKBENCH_UBO_World *wd = &wpd->world_data; + float view_matrix[4][4]; + DRW_viewport_matrix_get(view_matrix, DRW_MAT_VIEW); + + { + WORKBENCH_UBO_Light *light = &wd->lights[0]; + mul_v3_mat3_m4v3(light->light_direction_vs, view_matrix, light_direction); + light->light_direction_vs[3] = 0.0f; + copy_v3_fl(light->specular_color, 1.0f); + light->energy = 1.0f; + copy_v4_v4(wd->light_direction_vs, light->light_direction_vs); + wd->num_lights = 1; + } + + if (!STUDIOLIGHT_ORIENTATION_WORLD_ENABLED(wpd)) { + int light_index = 0; + for (int index = 0 ; index < 3; index++) { + SolidLight *sl = &U.light[index]; + if (sl->flag) { + WORKBENCH_UBO_Light *light = &wd->lights[light_index++]; + copy_v4_v4(light->light_direction_vs, sl->vec); + negate_v3(light->light_direction_vs); + copy_v4_v4(light->specular_color, sl->spec); + light->energy = 1.0f; + } + } + wd->num_lights = light_index; + } + + copy_v3_v3(light_direction, scene->display.light_direction); + negate_v3(light_direction); + DRW_uniformbuffer_update(wpd->world_ubo, wd); +} + +static void workbench_private_material_free(void *data) +{ + WORKBENCH_MaterialData *material_data = data; + DRW_UBO_FREE_SAFE(material_data->material_ubo); + MEM_freeN(material_data); +} + +void workbench_private_data_free(WORKBENCH_PrivateData *wpd) +{ + BLI_ghash_free(wpd->material_hash, NULL, workbench_private_material_free); + DRW_UBO_FREE_SAFE(wpd->world_ubo); +} diff --git a/source/blender/draw/engines/workbench/workbench_deferred.c b/source/blender/draw/engines/workbench/workbench_deferred.c new file mode 100644 index 00000000000..4fe3e92f10c --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_deferred.c @@ -0,0 +1,890 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_deferred.c + * \ingroup draw_engine + */ + +#include "workbench_private.h" + +#include "BIF_gl.h" + +#include "BLI_alloca.h" +#include "BLI_dynstr.h" +#include "BLI_utildefines.h" +#include "BLI_rand.h" + +#include "BKE_node.h" +#include "BKE_particle.h" + +#include "DNA_image_types.h" +#include "DNA_mesh_types.h" +#include "DNA_modifier_types.h" +#include "DNA_node_types.h" + +#include "ED_uvedit.h" + +#include "GPU_shader.h" +#include "GPU_texture.h" + +#include "../eevee/eevee_lut.h" /* TODO find somewhere to share blue noise Table */ + +/* *********** STATIC *********** */ + +/* #define DEBUG_SHADOW_VOLUME */ + +#ifdef DEBUG_SHADOW_VOLUME +# include "draw_debug.h" +#endif + +static struct { + struct GPUShader *prepass_sh_cache[MAX_SHADERS]; + struct GPUShader *composite_sh_cache[MAX_SHADERS]; + struct GPUShader *cavity_sh; + struct GPUShader *shadow_fail_sh; + struct GPUShader *shadow_fail_manifold_sh; + struct GPUShader *shadow_pass_sh; + struct GPUShader *shadow_pass_manifold_sh; + struct GPUShader *shadow_caps_sh; + struct GPUShader *shadow_caps_manifold_sh; + struct GPUShader *effect_fxaa_sh; + + struct GPUTexture *object_id_tx; /* ref only, not alloced */ + struct GPUTexture *color_buffer_tx; /* ref only, not alloced */ + struct GPUTexture *cavity_buffer_tx; /* ref only, not alloced */ + struct GPUTexture *specular_buffer_tx; /* ref only, not alloced */ + struct GPUTexture *normal_buffer_tx; /* ref only, not alloced */ + struct GPUTexture *composite_buffer_tx; /* ref only, not alloced */ + struct GPUTexture *effect_buffer_tx; /* ref only, not alloced */ + + SceneDisplay display; /* world light direction for shadows */ + int next_object_id; + float normal_world_matrix[3][3]; + + struct GPUUniformBuffer *sampling_ubo; + struct GPUTexture *jitter_tx; + int cached_sample_num; +} e_data = {{NULL}}; + +/* Shaders */ +extern char datatoc_common_fxaa_lib_glsl[]; +extern char datatoc_common_fullscreen_vert_glsl[]; +extern char datatoc_common_hair_lib_glsl[]; + +extern char datatoc_workbench_prepass_vert_glsl[]; +extern char datatoc_workbench_prepass_frag_glsl[]; +extern char datatoc_workbench_cavity_frag_glsl[]; +extern char datatoc_workbench_deferred_composite_frag_glsl[]; + +extern char datatoc_workbench_shadow_vert_glsl[]; +extern char datatoc_workbench_shadow_geom_glsl[]; +extern char datatoc_workbench_shadow_caps_geom_glsl[]; +extern char datatoc_workbench_shadow_debug_frag_glsl[]; + +extern char datatoc_workbench_background_lib_glsl[]; +extern char datatoc_workbench_cavity_lib_glsl[]; +extern char datatoc_workbench_common_lib_glsl[]; +extern char datatoc_workbench_data_lib_glsl[]; +extern char datatoc_workbench_effect_fxaa_frag_glsl[]; +extern char datatoc_workbench_object_outline_lib_glsl[]; +extern char datatoc_workbench_world_light_lib_glsl[]; + +static char *workbench_build_composite_frag(WORKBENCH_PrivateData *wpd) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_data_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_background_lib_glsl); + + if ((wpd->shading.light & V3D_LIGHTING_MATCAP) || (wpd->shading.light & V3D_LIGHTING_STUDIO) || (wpd->shading.flag & V3D_SHADING_SPECULAR_HIGHLIGHT)) { + BLI_dynstr_append(ds, datatoc_workbench_world_light_lib_glsl); + } + if (wpd->shading.flag & V3D_SHADING_OBJECT_OUTLINE) { + BLI_dynstr_append(ds, datatoc_workbench_object_outline_lib_glsl); + } + + BLI_dynstr_append(ds, datatoc_workbench_deferred_composite_frag_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_prepass_frag(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_data_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_prepass_frag_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_prepass_vert(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_common_hair_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_prepass_vert_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_cavity_frag(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_cavity_frag_glsl); + BLI_dynstr_append(ds, datatoc_workbench_cavity_lib_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static void ensure_deferred_shaders(WORKBENCH_PrivateData *wpd, int index, bool use_textures, bool is_hair) +{ + if (e_data.prepass_sh_cache[index] == NULL) { + char *defines = workbench_material_build_defines(wpd, use_textures, is_hair); + char *composite_frag = workbench_build_composite_frag(wpd); + char *prepass_vert = workbench_build_prepass_vert(); + char *prepass_frag = workbench_build_prepass_frag(); + e_data.prepass_sh_cache[index] = DRW_shader_create( + prepass_vert, NULL, + prepass_frag, defines); + if (!use_textures && !is_hair) { + e_data.composite_sh_cache[index] = DRW_shader_create_fullscreen(composite_frag, defines); + } + MEM_freeN(prepass_vert); + MEM_freeN(prepass_frag); + MEM_freeN(composite_frag); + MEM_freeN(defines); + } +} + +static void select_deferred_shaders(WORKBENCH_PrivateData *wpd) +{ + int index_solid = workbench_material_get_shader_index(wpd, false, false); + int index_solid_hair = workbench_material_get_shader_index(wpd, false, true); + int index_texture = workbench_material_get_shader_index(wpd, true, false); + int index_texture_hair = workbench_material_get_shader_index(wpd, true, true); + + ensure_deferred_shaders(wpd, index_solid, false, false); + ensure_deferred_shaders(wpd, index_solid_hair, false, true); + ensure_deferred_shaders(wpd, index_texture, true, false); + ensure_deferred_shaders(wpd, index_texture_hair, true, true); + + wpd->prepass_solid_sh = e_data.prepass_sh_cache[index_solid]; + wpd->prepass_solid_hair_sh = e_data.prepass_sh_cache[index_solid_hair]; + wpd->prepass_texture_sh = e_data.prepass_sh_cache[index_texture]; + wpd->prepass_texture_hair_sh = e_data.prepass_sh_cache[index_texture_hair]; + wpd->composite_sh = e_data.composite_sh_cache[index_solid]; +} + + +/* Using Hammersley distribution */ +static float *create_disk_samples(int num_samples) +{ + /* vec4 to ensure memory alignment. */ + float (*texels)[4] = MEM_mallocN(sizeof(float[4]) * num_samples, "concentric_tex"); + const float num_samples_inv = 1.0f / num_samples; + + for (int i = 0; i < num_samples; i++) { + float r = (i + 0.5f) * num_samples_inv; + double dphi; + BLI_hammersley_1D(i, &dphi); + + float phi = (float)dphi * 2.0f * M_PI; + texels[i][0] = cosf(phi); + texels[i][1] = sinf(phi); + /* This deliberatly distribute more samples + * at the center of the disk (and thus the shadow). */ + texels[i][2] = r; + } + + return (float *)texels; +} + +static struct GPUTexture *create_jitter_texture(int num_samples) +{ + float jitter[64 * 64][3]; + const float num_samples_inv = 1.0f / num_samples; + + for (int i = 0; i < 64 * 64; i++) { + float phi = blue_noise[i][0] * 2.0f * M_PI; + /* This rotate the sample per pixels */ + jitter[i][0] = cosf(phi); + jitter[i][1] = sinf(phi); + /* This offset the sample along it's direction axis (reduce banding) */ + float bn = blue_noise[i][1] - 0.5f; + CLAMP(bn, -0.499f, 0.499f); /* fix fireflies */ + jitter[i][2] = bn * num_samples_inv; + } + + UNUSED_VARS(bsdf_split_sum_ggx, btdf_split_sum_ggx, ltc_mag_ggx, ltc_mat_ggx, ltc_disk_integral); + + return DRW_texture_create_2D(64, 64, GPU_RGB16F, DRW_TEX_FILTER | DRW_TEX_WRAP, &jitter[0][0]); +} +/* Functions */ + + +static void workbench_init_object_data(ObjectEngineData *engine_data) +{ + WORKBENCH_ObjectData *data = (WORKBENCH_ObjectData *)engine_data; + data->object_id = ((e_data.next_object_id++) & 0xff) + 1; + data->shadow_bbox_dirty = true; +} + +void workbench_deferred_engine_init(WORKBENCH_Data *vedata) +{ + WORKBENCH_FramebufferList *fbl = vedata->fbl; + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + if (!e_data.next_object_id) { + memset(e_data.prepass_sh_cache, 0x00, sizeof(struct GPUShader *) * MAX_SHADERS); + memset(e_data.composite_sh_cache, 0x00, sizeof(struct GPUShader *) * MAX_SHADERS); + e_data.next_object_id = 1; +#ifdef DEBUG_SHADOW_VOLUME + const char *shadow_frag = datatoc_workbench_shadow_debug_frag_glsl; +#else + const char *shadow_frag = NULL; +#endif + e_data.shadow_pass_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_geom_glsl, + shadow_frag, + "#define SHADOW_PASS\n" + "#define DOUBLE_MANIFOLD\n"); + e_data.shadow_pass_manifold_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_geom_glsl, + shadow_frag, + "#define SHADOW_PASS\n"); + e_data.shadow_fail_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_geom_glsl, + shadow_frag, + "#define SHADOW_FAIL\n" + "#define DOUBLE_MANIFOLD\n"); + e_data.shadow_fail_manifold_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_geom_glsl, + shadow_frag, + "#define SHADOW_FAIL\n"); + e_data.shadow_caps_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_caps_geom_glsl, + shadow_frag, + "#define SHADOW_FAIL\n" + "#define DOUBLE_MANIFOLD\n"); + e_data.shadow_caps_manifold_sh = DRW_shader_create( + datatoc_workbench_shadow_vert_glsl, + datatoc_workbench_shadow_caps_geom_glsl, + shadow_frag, + "#define SHADOW_FAIL\n"); + + char *cavity_frag = workbench_build_cavity_frag(); + e_data.cavity_sh = DRW_shader_create_fullscreen(cavity_frag, NULL); + MEM_freeN(cavity_frag); + + e_data.effect_fxaa_sh = DRW_shader_create_with_lib( + datatoc_common_fullscreen_vert_glsl, NULL, + datatoc_workbench_effect_fxaa_frag_glsl, + datatoc_common_fxaa_lib_glsl, + NULL); + } + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(*stl->g_data), __func__); + } + + WORKBENCH_PrivateData *wpd = stl->g_data; + workbench_private_data_init(wpd); + + { + const float *viewport_size = DRW_viewport_size_get(); + const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]}; + e_data.object_id_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_R32UI, &draw_engine_workbench_solid); + e_data.color_buffer_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8, &draw_engine_workbench_solid); + e_data.cavity_buffer_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RG16, &draw_engine_workbench_solid); + e_data.specular_buffer_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8, &draw_engine_workbench_solid); + e_data.composite_buffer_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_RGBA16F, &draw_engine_workbench_solid); + e_data.effect_buffer_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_RGBA16F, &draw_engine_workbench_solid); + + if (NORMAL_ENCODING_ENABLED()) { + e_data.normal_buffer_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_RG16, &draw_engine_workbench_solid); + } + else { + e_data.normal_buffer_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_RGBA32F, &draw_engine_workbench_solid); + } + + GPU_framebuffer_ensure_config(&fbl->prepass_fb, { + GPU_ATTACHMENT_TEXTURE(dtxl->depth), + GPU_ATTACHMENT_TEXTURE(e_data.object_id_tx), + GPU_ATTACHMENT_TEXTURE(e_data.color_buffer_tx), + GPU_ATTACHMENT_TEXTURE(e_data.specular_buffer_tx), + GPU_ATTACHMENT_TEXTURE(e_data.normal_buffer_tx), + }); + GPU_framebuffer_ensure_config(&fbl->cavity_fb, { + GPU_ATTACHMENT_NONE, + GPU_ATTACHMENT_TEXTURE(e_data.cavity_buffer_tx), + }); + GPU_framebuffer_ensure_config(&fbl->composite_fb, { + GPU_ATTACHMENT_TEXTURE(dtxl->depth), + GPU_ATTACHMENT_TEXTURE(e_data.composite_buffer_tx), + }); + GPU_framebuffer_ensure_config(&fbl->effect_fb, { + GPU_ATTACHMENT_NONE, + GPU_ATTACHMENT_TEXTURE(e_data.effect_buffer_tx), + }); + } + + { + const DRWContextState *draw_ctx = DRW_context_state_get(); + Scene *scene = draw_ctx->scene; + /* AO Samples Tex */ + const int ssao_samples = scene->display.matcap_ssao_samples; + if (e_data.sampling_ubo && (e_data.cached_sample_num != ssao_samples)) { + DRW_UBO_FREE_SAFE(e_data.sampling_ubo); + DRW_TEXTURE_FREE_SAFE(e_data.jitter_tx); + } + + if (e_data.sampling_ubo == NULL) { + float *samples = create_disk_samples(ssao_samples); + e_data.jitter_tx = create_jitter_texture(ssao_samples); + e_data.sampling_ubo = DRW_uniformbuffer_create(sizeof(float[4]) * ssao_samples, samples); + e_data.cached_sample_num = ssao_samples; + MEM_freeN(samples); + } + } + + /* Prepass */ + { + int state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL; + psl->prepass_pass = DRW_pass_create("Prepass", state); + psl->prepass_hair_pass = DRW_pass_create("Prepass", state); + } + + { + int state = DRW_STATE_WRITE_COLOR; + psl->cavity_pass = DRW_pass_create("Cavity", state); + DRWShadingGroup *grp = DRW_shgroup_create(e_data.cavity_sh, psl->cavity_pass); + DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth); + DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &e_data.color_buffer_tx); + DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &e_data.normal_buffer_tx); + + DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + DRW_shgroup_uniform_vec4(grp, "viewvecs[0]", (float *)wpd->viewvecs, 3); + DRW_shgroup_uniform_vec4(grp, "ssao_params", wpd->ssao_params, 1); + DRW_shgroup_uniform_vec4(grp, "ssao_settings", wpd->ssao_settings, 1); + DRW_shgroup_uniform_mat4(grp, "WinMatrix", wpd->winmat); + DRW_shgroup_uniform_texture(grp, "ssao_jitter", e_data.jitter_tx); + DRW_shgroup_uniform_block(grp, "samples_block", e_data.sampling_ubo); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + } + + { + psl->effect_fxaa_pass = DRW_pass_create("Effect FXAA", DRW_STATE_WRITE_COLOR); + DRWShadingGroup *grp = DRW_shgroup_create(e_data.effect_fxaa_sh, psl->effect_fxaa_pass); + DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &e_data.effect_buffer_tx); + DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + } +} + +void workbench_deferred_engine_free() +{ + for (int index = 0; index < MAX_SHADERS; index++) { + DRW_SHADER_FREE_SAFE(e_data.prepass_sh_cache[index]); + DRW_SHADER_FREE_SAFE(e_data.composite_sh_cache[index]); + } + DRW_SHADER_FREE_SAFE(e_data.cavity_sh); + DRW_UBO_FREE_SAFE(e_data.sampling_ubo); + DRW_TEXTURE_FREE_SAFE(e_data.jitter_tx); + + DRW_SHADER_FREE_SAFE(e_data.shadow_pass_sh); + DRW_SHADER_FREE_SAFE(e_data.shadow_pass_manifold_sh); + DRW_SHADER_FREE_SAFE(e_data.shadow_fail_sh); + DRW_SHADER_FREE_SAFE(e_data.shadow_fail_manifold_sh); + DRW_SHADER_FREE_SAFE(e_data.shadow_caps_sh); + DRW_SHADER_FREE_SAFE(e_data.shadow_caps_manifold_sh); + + DRW_SHADER_FREE_SAFE(e_data.effect_fxaa_sh); +} + +static void workbench_composite_uniforms(WORKBENCH_PrivateData *wpd, DRWShadingGroup *grp) +{ + DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &e_data.color_buffer_tx); + DRW_shgroup_uniform_texture_ref(grp, "objectId", &e_data.object_id_tx); + if (NORMAL_VIEWPORT_COMP_PASS_ENABLED(wpd)) { + DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &e_data.normal_buffer_tx); + } + if (CAVITY_ENABLED(wpd)) { + DRW_shgroup_uniform_texture_ref(grp, "cavityBuffer", &e_data.cavity_buffer_tx); + } + if (SPECULAR_HIGHLIGHT_ENABLED(wpd) || MATCAP_ENABLED(wpd)) { + DRW_shgroup_uniform_texture_ref(grp, "specularBuffer", &e_data.specular_buffer_tx); + DRW_shgroup_uniform_vec4(grp, "viewvecs[0]", (float *)wpd->viewvecs, 3); + } + DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo); + DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + + if (STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd)) { + BKE_studiolight_ensure_flag(wpd->studio_light, STUDIOLIGHT_EQUIRECTANGULAR_RADIANCE_GPUTEXTURE); + DRW_shgroup_uniform_texture(grp, "matcapImage", wpd->studio_light->equirectangular_radiance_gputexture); + } + + workbench_material_set_normal_world_matrix(grp, wpd, e_data.normal_world_matrix); +} + +void workbench_deferred_cache_init(WORKBENCH_Data *vedata) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + DRWShadingGroup *grp; + const DRWContextState *draw_ctx = DRW_context_state_get(); + + Scene *scene = draw_ctx->scene; + + select_deferred_shaders(wpd); + /* Deferred Mix Pass */ + { + workbench_private_data_get_light_direction(wpd, e_data.display.light_direction); + studiolight_update_light(wpd, e_data.display.light_direction); + + e_data.display.shadow_shift = scene->display.shadow_shift; + + if (SHADOW_ENABLED(wpd)) { + psl->composite_pass = DRW_pass_create( + "Composite", DRW_STATE_WRITE_COLOR | DRW_STATE_STENCIL_EQUAL); + grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_pass); + workbench_composite_uniforms(wpd, grp); + DRW_shgroup_stencil_mask(grp, 0x00); + DRW_shgroup_uniform_float_copy(grp, "lightMultiplier", 1.0f); + DRW_shgroup_uniform_float(grp, "shadowMultiplier", &wpd->shadow_multiplier, 1); + DRW_shgroup_uniform_float(grp, "shadowShift", &scene->display.shadow_shift, 1); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + + /* Stencil Shadow passes. */ +#ifdef DEBUG_SHADOW_VOLUME + DRWState depth_pass_state = DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_COLOR | DRW_STATE_ADDITIVE; + DRWState depth_fail_state = DRW_STATE_DEPTH_GREATER_EQUAL | DRW_STATE_WRITE_COLOR | DRW_STATE_ADDITIVE; +#else + DRWState depth_pass_state = DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_STENCIL_SHADOW_PASS; + DRWState depth_fail_state = DRW_STATE_DEPTH_LESS | DRW_STATE_WRITE_STENCIL_SHADOW_FAIL; +#endif + psl->shadow_depth_pass_pass = DRW_pass_create("Shadow Pass", depth_pass_state); + psl->shadow_depth_pass_mani_pass = DRW_pass_create("Shadow Pass Mani", depth_pass_state); + psl->shadow_depth_fail_pass = DRW_pass_create("Shadow Fail", depth_fail_state); + psl->shadow_depth_fail_mani_pass = DRW_pass_create("Shadow Fail Mani", depth_fail_state); + psl->shadow_depth_fail_caps_pass = DRW_pass_create("Shadow Fail Caps", depth_fail_state); + psl->shadow_depth_fail_caps_mani_pass = DRW_pass_create("Shadow Fail Caps Mani", depth_fail_state); + +#ifndef DEBUG_SHADOW_VOLUME + grp = DRW_shgroup_create(e_data.shadow_pass_sh, psl->shadow_depth_pass_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + grp = DRW_shgroup_create(e_data.shadow_pass_manifold_sh, psl->shadow_depth_pass_mani_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + grp = DRW_shgroup_create(e_data.shadow_fail_sh, psl->shadow_depth_fail_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + grp = DRW_shgroup_create(e_data.shadow_fail_manifold_sh, psl->shadow_depth_fail_mani_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + grp = DRW_shgroup_create(e_data.shadow_caps_sh, psl->shadow_depth_fail_caps_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + grp = DRW_shgroup_create(e_data.shadow_caps_manifold_sh, psl->shadow_depth_fail_caps_mani_pass); + DRW_shgroup_stencil_mask(grp, 0xFF); + + psl->composite_shadow_pass = DRW_pass_create("Composite Shadow", DRW_STATE_WRITE_COLOR | DRW_STATE_STENCIL_NEQUAL); + grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_shadow_pass); + DRW_shgroup_stencil_mask(grp, 0x00); + workbench_composite_uniforms(wpd, grp); + DRW_shgroup_uniform_float(grp, "lightMultiplier", &wpd->shadow_multiplier, 1); + DRW_shgroup_uniform_float(grp, "shadowMultiplier", &wpd->shadow_multiplier, 1); + DRW_shgroup_uniform_float(grp, "shadowShift", &scene->display.shadow_shift, 1); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); +#endif + + } + else { + psl->composite_pass = DRW_pass_create( + "Composite", DRW_STATE_WRITE_COLOR); + grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_pass); + workbench_composite_uniforms(wpd, grp); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + } + } +} + +static WORKBENCH_MaterialData *get_or_create_material_data( + WORKBENCH_Data *vedata, Object *ob, Material *mat, Image *ima, int color_type) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + WORKBENCH_MaterialData *material; + WORKBENCH_ObjectData *engine_object_data = (WORKBENCH_ObjectData *)DRW_object_engine_data_ensure( + ob, &draw_engine_workbench_solid, sizeof(WORKBENCH_ObjectData), &workbench_init_object_data, NULL); + WORKBENCH_MaterialData material_template; + + /* Solid */ + workbench_material_update_data(wpd, ob, mat, &material_template); + material_template.object_id = OBJECT_ID_PASS_ENABLED(wpd) ? engine_object_data->object_id : 1; + material_template.color_type = color_type; + material_template.ima = ima; + uint hash = workbench_material_get_hash(&material_template); + + material = BLI_ghash_lookup(wpd->material_hash, SET_UINT_IN_POINTER(hash)); + if (material == NULL) { + material = MEM_mallocN(sizeof(WORKBENCH_MaterialData), __func__); + material->shgrp = DRW_shgroup_create( + color_type == V3D_SHADING_TEXTURE_COLOR ? wpd->prepass_texture_sh: wpd->prepass_solid_sh, psl->prepass_pass); + DRW_shgroup_stencil_mask(material->shgrp, 0xFF); + material->object_id = material_template.object_id; + copy_v4_v4(material->material_data.diffuse_color, material_template.material_data.diffuse_color); + copy_v4_v4(material->material_data.specular_color, material_template.material_data.specular_color); + material->material_data.roughness = material_template.material_data.roughness; + if (color_type == V3D_SHADING_TEXTURE_COLOR) { + GPUTexture *tex = GPU_texture_from_blender(ima, NULL, GL_TEXTURE_2D, false, 0.0); + DRW_shgroup_uniform_texture(material->shgrp, "image", tex); + } + DRW_shgroup_uniform_int(material->shgrp, "object_id", &material->object_id, 1); + material->material_ubo = DRW_uniformbuffer_create(sizeof(WORKBENCH_UBO_Material), &material->material_data); + DRW_shgroup_uniform_block(material->shgrp, "material_block", material->material_ubo); + + BLI_ghash_insert(wpd->material_hash, SET_UINT_IN_POINTER(hash), material); + } + return material; +} + +static void workbench_cache_populate_particles(WORKBENCH_Data *vedata, Object *ob) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + const DRWContextState *draw_ctx = DRW_context_state_get(); + if (ob == draw_ctx->object_edit) { + return; + } + for (ModifierData *md = ob->modifiers.first; md; md = md->next) { + if (md->type != eModifierType_ParticleSystem) { + continue; + } + ParticleSystem *psys = ((ParticleSystemModifierData *)md)->psys; + if (!psys_check_enabled(ob, psys, false)) { + continue; + } + if (!DRW_check_psys_visible_within_active_context(ob, psys)) { + continue; + } + ParticleSettings *part = psys->part; + const int draw_as = (part->draw_as == PART_DRAW_REND) ? part->ren_as : part->draw_as; + + if (draw_as == PART_DRAW_PATH) { + Image *image = NULL; + Material *mat = give_current_material(ob, part->omat); + ED_object_get_active_image(ob, part->omat, &image, NULL, NULL, NULL); + int color_type = workbench_material_determine_color_type(wpd, image); + WORKBENCH_MaterialData *material = get_or_create_material_data(vedata, ob, mat, image, color_type); + + struct GPUShader *shader = (color_type != V3D_SHADING_TEXTURE_COLOR) + ? wpd->prepass_solid_hair_sh + : wpd->prepass_texture_hair_sh; + DRWShadingGroup *shgrp = DRW_shgroup_hair_create( + ob, psys, md, + psl->prepass_hair_pass, + shader); + DRW_shgroup_stencil_mask(shgrp, 0xFF); + DRW_shgroup_uniform_int(shgrp, "object_id", &material->object_id, 1); + DRW_shgroup_uniform_block(shgrp, "material_block", material->material_ubo); + if (image) { + GPUTexture *tex = GPU_texture_from_blender(image, NULL, GL_TEXTURE_2D, false, 0.0f); + DRW_shgroup_uniform_texture(shgrp, "image", tex); + } + } + } +} + +void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + if (!DRW_object_is_renderable(ob)) + return; + + if (ob->type == OB_MESH) { + workbench_cache_populate_particles(vedata, ob); + } + + if (!DRW_check_object_visible_within_active_context(ob)) { + return; + } + + WORKBENCH_MaterialData *material; + if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) { + const DRWContextState *draw_ctx = DRW_context_state_get(); + const bool is_active = (ob == draw_ctx->obact); + const bool is_sculpt_mode = is_active && (draw_ctx->object_mode & OB_MODE_SCULPT) != 0; + bool is_drawn = false; + if (!is_sculpt_mode && TEXTURE_DRAWING_ENABLED(wpd) && ELEM(ob->type, OB_MESH)) { + const Mesh *me = ob->data; + if (me->mloopuv) { + const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol)); + struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len); + struct Gwn_Batch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob) : NULL; + if (materials_len > 0 && geom_array) { + for (int i = 0; i < materials_len; i++) { + if (geom_array[i] == NULL) { + continue; + } + + Material *mat = give_current_material(ob, i + 1); + Image *image; + ED_object_get_active_image(ob, i + 1, &image, NULL, NULL, NULL); + int color_type = workbench_material_determine_color_type(wpd, image); + material = get_or_create_material_data(vedata, ob, mat, image, color_type); + DRW_shgroup_call_object_add(material->shgrp, geom_array[i], ob); + } + is_drawn = true; + } + } + } + + /* Fallback from not drawn OB_TEXTURE mode or just OB_SOLID mode */ + if (!is_drawn) { + if (ELEM(wpd->shading.color_type, V3D_SHADING_SINGLE_COLOR, V3D_SHADING_RANDOM_COLOR)) { + /* No material split needed */ + struct Gwn_Batch *geom = DRW_cache_object_surface_get(ob); + if (geom) { + material = get_or_create_material_data(vedata, ob, NULL, NULL, wpd->shading.color_type); + if (is_sculpt_mode) { + DRW_shgroup_call_sculpt_add(material->shgrp, ob, ob->obmat); + } + else { + DRW_shgroup_call_object_add(material->shgrp, geom, ob); + } + } + } + else { /* MATERIAL colors */ + const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol)); + struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len); + for (int i = 0; i < materials_len; i++) { + gpumat_array[i] = NULL; + } + + struct Gwn_Batch **mat_geom = DRW_cache_object_surface_material_get( + ob, gpumat_array, materials_len, NULL, NULL, NULL); + if (mat_geom) { + for (int i = 0; i < materials_len; ++i) { + if (mat_geom[i] == NULL) { + continue; + } + + Material *mat = give_current_material(ob, i + 1); + material = get_or_create_material_data(vedata, ob, mat, NULL, V3D_SHADING_MATERIAL_COLOR); + if (is_sculpt_mode) { + DRW_shgroup_call_sculpt_add(material->shgrp, ob, ob->obmat); + } + else { + DRW_shgroup_call_object_add(material->shgrp, mat_geom[i], ob); + } + } + } + } + } + + if (SHADOW_ENABLED(wpd) && (ob->display.flag & OB_SHOW_SHADOW) > 0) { + bool is_manifold; + struct Gwn_Batch *geom_shadow = DRW_cache_object_edge_detection_get(ob, &is_manifold); + if (geom_shadow) { + if (is_sculpt_mode) { + /* Currently unsupported in sculpt mode. We could revert to the slow + * method in this case but i'm not sure if it's a good idea given that + * sculped meshes are heavy to begin with. */ + // DRW_shgroup_call_sculpt_add(wpd->shadow_shgrp, ob, ob->obmat); + } + else { + WORKBENCH_ObjectData *engine_object_data = (WORKBENCH_ObjectData *)DRW_object_engine_data_ensure( + ob, &draw_engine_workbench_solid, sizeof(WORKBENCH_ObjectData), &workbench_init_object_data, NULL); + + if (studiolight_object_cast_visible_shadow(wpd, ob, engine_object_data)) { + + invert_m4_m4(ob->imat, ob->obmat); + mul_v3_mat3_m4v3(engine_object_data->shadow_dir, ob->imat, e_data.display.light_direction); + + DRWShadingGroup *grp; + bool use_shadow_pass_technique = !studiolight_camera_in_object_shadow(wpd, ob, engine_object_data); + + if (use_shadow_pass_technique) { + if (is_manifold) { + grp = DRW_shgroup_create(e_data.shadow_pass_manifold_sh, psl->shadow_depth_pass_mani_pass); + } + else { + grp = DRW_shgroup_create(e_data.shadow_pass_sh, psl->shadow_depth_pass_pass); + } + DRW_shgroup_uniform_vec3(grp, "lightDirection", engine_object_data->shadow_dir, 1); + DRW_shgroup_uniform_float_copy(grp, "lightDistance", 1e5f); + DRW_shgroup_call_add(grp, geom_shadow, ob->obmat); +#ifdef DEBUG_SHADOW_VOLUME + DRW_debug_bbox(&engine_object_data->shadow_bbox, (float[4]){1.0f, 0.0f, 0.0f, 1.0f}); +#endif + } + else { + float extrude_distance = studiolight_object_shadow_distance(wpd, ob, engine_object_data); + + /* TODO(fclem): only use caps if they are in the view frustum. */ + const bool need_caps = true; + if (need_caps) { + if (is_manifold) { + grp = DRW_shgroup_create(e_data.shadow_caps_manifold_sh, psl->shadow_depth_fail_caps_mani_pass); + } + else { + grp = DRW_shgroup_create(e_data.shadow_caps_sh, psl->shadow_depth_fail_caps_pass); + } + DRW_shgroup_uniform_vec3(grp, "lightDirection", engine_object_data->shadow_dir, 1); + DRW_shgroup_uniform_float_copy(grp, "lightDistance", extrude_distance); + DRW_shgroup_call_add(grp, DRW_cache_object_surface_get(ob), ob->obmat); + } + + if (is_manifold) { + grp = DRW_shgroup_create(e_data.shadow_fail_manifold_sh, psl->shadow_depth_fail_mani_pass); + } + else { + grp = DRW_shgroup_create(e_data.shadow_fail_sh, psl->shadow_depth_fail_pass); + } + DRW_shgroup_uniform_vec3(grp, "lightDirection", engine_object_data->shadow_dir, 1); + DRW_shgroup_uniform_float_copy(grp, "lightDistance", extrude_distance); + DRW_shgroup_call_add(grp, geom_shadow, ob->obmat); +#ifdef DEBUG_SHADOW_VOLUME + DRW_debug_bbox(&engine_object_data->shadow_bbox, (float[4]){0.0f, 1.0f, 0.0f, 1.0f}); +#endif + } + } + } + } + } + } +} + +void workbench_deferred_cache_finish(WORKBENCH_Data *UNUSED(vedata)) +{ +} + +void workbench_deferred_draw_background(WORKBENCH_Data *vedata) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_FramebufferList *fbl = vedata->fbl; + WORKBENCH_PrivateData *wpd = stl->g_data; + const float clear_depth = 1.0f; + const float clear_color[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + uint clear_stencil = 0xFF; + + DRW_stats_group_start("Clear Background"); + GPU_framebuffer_bind(fbl->prepass_fb); + int clear_bits = GPU_DEPTH_BIT | GPU_COLOR_BIT; + SET_FLAG_FROM_TEST(clear_bits, SHADOW_ENABLED(wpd), GPU_STENCIL_BIT); + GPU_framebuffer_clear(fbl->prepass_fb, clear_bits, clear_color, clear_depth, clear_stencil); + DRW_stats_group_end(); +} + +void workbench_deferred_draw_scene(WORKBENCH_Data *vedata) +{ + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_FramebufferList *fbl = vedata->fbl; + WORKBENCH_PrivateData *wpd = stl->g_data; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + + /* clear in background */ + GPU_framebuffer_bind(fbl->prepass_fb); + DRW_draw_pass(psl->prepass_pass); + DRW_draw_pass(psl->prepass_hair_pass); + + if (CAVITY_ENABLED(wpd)) { + GPU_framebuffer_bind(fbl->cavity_fb); + DRW_draw_pass(psl->cavity_pass); + } + + if (SHADOW_ENABLED(wpd)) { +#ifdef DEBUG_SHADOW_VOLUME + GPU_framebuffer_bind(fbl->composite_fb); + DRW_draw_pass(psl->composite_pass); +#else + GPU_framebuffer_bind(dfbl->depth_only_fb); +#endif + DRW_draw_pass(psl->shadow_depth_pass_pass); + DRW_draw_pass(psl->shadow_depth_pass_mani_pass); + DRW_draw_pass(psl->shadow_depth_fail_pass); + DRW_draw_pass(psl->shadow_depth_fail_mani_pass); + DRW_draw_pass(psl->shadow_depth_fail_caps_pass); + DRW_draw_pass(psl->shadow_depth_fail_caps_mani_pass); +#ifndef DEBUG_SHADOW_VOLUME + GPU_framebuffer_bind(fbl->composite_fb); + DRW_draw_pass(psl->composite_pass); + DRW_draw_pass(psl->composite_shadow_pass); +#endif + } + else { + GPU_framebuffer_bind(fbl->composite_fb); + DRW_draw_pass(psl->composite_pass); + } + + if (FXAA_ENABLED(wpd)) { + GPU_framebuffer_bind(fbl->effect_fb); + DRW_transform_to_display(e_data.composite_buffer_tx); + + /* TODO: when rendering the fxaa pass should be done in display space + Currently we do not support rendering in the workbench + */ + GPU_framebuffer_bind(dfbl->color_only_fb); + DRW_draw_pass(psl->effect_fxaa_pass); + } + else { + GPU_framebuffer_bind(dfbl->color_only_fb); + DRW_transform_to_display(e_data.composite_buffer_tx); + } + + + workbench_private_data_free(wpd); +} diff --git a/source/blender/draw/engines/workbench/workbench_engine.c b/source/blender/draw/engines/workbench/workbench_engine.c new file mode 100644 index 00000000000..26ae1c289c8 --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_engine.c @@ -0,0 +1,47 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_engine.c + * \ingroup draw_engine + * + * Simple engine for drawing color and/or depth. + * When we only need simple flat shaders. + */ + +#include "DRW_render.h" + +#include "workbench_engine.h" +/* Shaders */ + +#define WORKBENCH_ENGINE "BLENDER_WORKBENCH" + + +/* Note: currently unused, we may want to register so we can see this when debugging the view. */ +RenderEngineType DRW_engine_viewport_workbench_type = { + NULL, NULL, + WORKBENCH_ENGINE, N_("Workbench"), RE_INTERNAL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, + &draw_engine_workbench_solid, + {NULL, NULL, NULL} +}; + + +#undef WORKBENCH_ENGINE diff --git a/source/blender/draw/engines/workbench/workbench_engine.h b/source/blender/draw/engines/workbench/workbench_engine.h new file mode 100644 index 00000000000..a7f168db093 --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_engine.h @@ -0,0 +1,33 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_engine.h + * \ingroup draw_engine + */ + +#ifndef __WORKBENCH_ENGINE_H__ +#define __WORKBENCH_ENGINE_H__ + +extern DrawEngineType draw_engine_workbench_solid; +extern DrawEngineType draw_engine_workbench_transparent; +extern RenderEngineType DRW_engine_viewport_workbench_type; + +#endif /* __WORKBENCH_ENGINE_H__ */ diff --git a/source/blender/draw/engines/workbench/workbench_forward.c b/source/blender/draw/engines/workbench/workbench_forward.c new file mode 100644 index 00000000000..9f23cd5b43b --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_forward.c @@ -0,0 +1,595 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_forward.c + * \ingroup draw_engine + */ + +#include "workbench_private.h" + +#include "BIF_gl.h" + +#include "BLI_alloca.h" +#include "BLI_dynstr.h" +#include "BLI_utildefines.h" + +#include "BKE_node.h" +#include "BKE_particle.h" + +#include "DNA_image_types.h" +#include "DNA_mesh_types.h" +#include "DNA_modifier_types.h" +#include "DNA_node_types.h" + +#include "ED_uvedit.h" + +#include "GPU_shader.h" +#include "GPU_texture.h" + +#include "UI_resources.h" + +/* *********** STATIC *********** */ +static struct { + struct GPUShader *composite_sh_cache[MAX_SHADERS]; + struct GPUShader *transparent_accum_sh_cache[MAX_SHADERS]; + struct GPUShader *object_outline_sh; + struct GPUShader *object_outline_hair_sh; + struct GPUShader *checker_depth_sh; + + struct GPUTexture *object_id_tx; /* ref only, not alloced */ + struct GPUTexture *transparent_accum_tx; /* ref only, not alloced */ + struct GPUTexture *transparent_revealage_tx; /* ref only, not alloced */ + struct GPUTexture *composite_buffer_tx; /* ref only, not alloced */ + int next_object_id; + float normal_world_matrix[3][3]; +} e_data = {{NULL}}; + +/* Shaders */ +extern char datatoc_common_hair_lib_glsl[]; +extern char datatoc_workbench_forward_composite_frag_glsl[]; +extern char datatoc_workbench_forward_depth_frag_glsl[]; +extern char datatoc_workbench_forward_transparent_accum_frag_glsl[]; +extern char datatoc_workbench_data_lib_glsl[]; +extern char datatoc_workbench_background_lib_glsl[]; +extern char datatoc_workbench_checkerboard_depth_frag_glsl[]; +extern char datatoc_workbench_object_outline_lib_glsl[]; +extern char datatoc_workbench_prepass_vert_glsl[]; +extern char datatoc_workbench_common_lib_glsl[]; +extern char datatoc_workbench_world_light_lib_glsl[]; + +/* static functions */ +static char *workbench_build_forward_depth_frag(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_forward_depth_frag_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_forward_vert(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_common_hair_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_prepass_vert_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_forward_transparent_accum_frag(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_data_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_world_light_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_forward_transparent_accum_frag_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static char *workbench_build_forward_composite_frag(void) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + BLI_dynstr_append(ds, datatoc_workbench_data_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_common_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_background_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_object_outline_lib_glsl); + BLI_dynstr_append(ds, datatoc_workbench_forward_composite_frag_glsl); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +static void workbench_init_object_data(ObjectEngineData *engine_data) +{ + WORKBENCH_ObjectData *data = (WORKBENCH_ObjectData *)engine_data; + data->object_id = ((e_data.next_object_id++) & 0xff) + 1; +} + +static WORKBENCH_MaterialData *get_or_create_material_data( + WORKBENCH_Data *vedata, Object *ob, Material *mat, Image *ima, int color_type) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + WORKBENCH_MaterialData *material; + WORKBENCH_ObjectData *engine_object_data = (WORKBENCH_ObjectData *)DRW_object_engine_data_ensure( + ob, &draw_engine_workbench_solid, sizeof(WORKBENCH_ObjectData), &workbench_init_object_data, NULL); + WORKBENCH_MaterialData material_template; + DRWShadingGroup *grp; + + /* Solid */ + workbench_material_update_data(wpd, ob, mat, &material_template); + material_template.object_id = OBJECT_ID_PASS_ENABLED(wpd) ? engine_object_data->object_id : 1; + material_template.color_type = color_type; + material_template.ima = ima; + uint hash = workbench_material_get_hash(&material_template); + + material = BLI_ghash_lookup(wpd->material_hash, SET_UINT_IN_POINTER(hash)); + if (material == NULL) { + material = MEM_mallocN(sizeof(WORKBENCH_MaterialData), __func__); + + /* transparent accum */ + grp = DRW_shgroup_create( + color_type == V3D_SHADING_TEXTURE_COLOR ? wpd->transparent_accum_texture_sh: wpd->transparent_accum_sh, + psl->transparent_accum_pass); + DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo); + DRW_shgroup_uniform_float(grp, "alpha", &wpd->shading.xray_alpha, 1); + DRW_shgroup_uniform_vec4(grp, "viewvecs[0]", (float *)wpd->viewvecs, 3); + workbench_material_set_normal_world_matrix(grp, wpd, e_data.normal_world_matrix); + material->object_id = engine_object_data->object_id; + copy_v4_v4(material->material_data.diffuse_color, material_template.material_data.diffuse_color); + copy_v4_v4(material->material_data.specular_color, material_template.material_data.specular_color); + material->material_data.roughness = material_template.material_data.roughness; + + if (color_type == V3D_SHADING_TEXTURE_COLOR) { + GPUTexture *tex = GPU_texture_from_blender(ima, NULL, GL_TEXTURE_2D, false, 0.0f); + DRW_shgroup_uniform_texture(grp, "image", tex); + } + if (STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd)) { + BKE_studiolight_ensure_flag(wpd->studio_light, STUDIOLIGHT_EQUIRECTANGULAR_RADIANCE_GPUTEXTURE); + DRW_shgroup_uniform_texture(grp, "matcapImage", wpd->studio_light->equirectangular_radiance_gputexture); + } + if (SPECULAR_HIGHLIGHT_ENABLED(wpd) || MATCAP_ENABLED(wpd)) { + DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + } + + material->material_ubo = DRW_uniformbuffer_create(sizeof(WORKBENCH_UBO_Material), &material->material_data); + DRW_shgroup_uniform_block(grp, "material_block", material->material_ubo); + material->shgrp = grp; + + /* Depth */ + material->shgrp_object_outline = DRW_shgroup_create(e_data.object_outline_sh, psl->object_outline_pass); + material->object_id = engine_object_data->object_id; + DRW_shgroup_uniform_int(material->shgrp_object_outline, "object_id", &material->object_id, 1); + BLI_ghash_insert(wpd->material_hash, SET_UINT_IN_POINTER(hash), material); + } + return material; +} + +static void ensure_forward_shaders(WORKBENCH_PrivateData *wpd, int index, bool use_textures, bool is_hair) +{ + if (e_data.composite_sh_cache[index] == NULL && !use_textures && !is_hair) { + char *defines = workbench_material_build_defines(wpd, use_textures, is_hair); + char *composite_frag = workbench_build_forward_composite_frag(); + e_data.composite_sh_cache[index] = DRW_shader_create_fullscreen(composite_frag, defines); + MEM_freeN(composite_frag); + MEM_freeN(defines); + } + + if (e_data.transparent_accum_sh_cache[index] == NULL) { + char *defines = workbench_material_build_defines(wpd, use_textures, is_hair); + char *transparent_accum_vert = workbench_build_forward_vert(); + char *transparent_accum_frag = workbench_build_forward_transparent_accum_frag(); + e_data.transparent_accum_sh_cache[index] = DRW_shader_create( + transparent_accum_vert, NULL, + transparent_accum_frag, defines); + MEM_freeN(transparent_accum_vert); + MEM_freeN(transparent_accum_frag); + MEM_freeN(defines); + } +} + +static void select_forward_shaders(WORKBENCH_PrivateData *wpd) +{ + int index_solid = workbench_material_get_shader_index(wpd, false, false); + int index_solid_hair = workbench_material_get_shader_index(wpd, false, true); + int index_texture = workbench_material_get_shader_index(wpd, true, false); + int index_texture_hair = workbench_material_get_shader_index(wpd, true, true); + + ensure_forward_shaders(wpd, index_solid, false, false); + ensure_forward_shaders(wpd, index_solid_hair, false, true); + ensure_forward_shaders(wpd, index_texture, true, false); + ensure_forward_shaders(wpd, index_texture_hair, true, true); + + wpd->composite_sh = e_data.composite_sh_cache[index_solid]; + wpd->transparent_accum_sh = e_data.transparent_accum_sh_cache[index_solid]; + wpd->transparent_accum_hair_sh = e_data.transparent_accum_sh_cache[index_solid_hair]; + wpd->transparent_accum_texture_sh = e_data.transparent_accum_sh_cache[index_texture]; + wpd->transparent_accum_texture_hair_sh = e_data.transparent_accum_sh_cache[index_texture_hair]; +} + +/* public functions */ +void workbench_forward_engine_init(WORKBENCH_Data *vedata) +{ + WORKBENCH_FramebufferList *fbl = vedata->fbl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_StorageList *stl = vedata->stl; + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + DRWShadingGroup *grp; + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(*stl->g_data), __func__); + } + WORKBENCH_PrivateData *wpd = stl->g_data; + workbench_private_data_init(wpd); + float light_direction[3]; + workbench_private_data_get_light_direction(wpd, light_direction); + + if (!e_data.next_object_id) { + e_data.next_object_id = 1; + memset(e_data.composite_sh_cache, 0x00, sizeof(struct GPUShader *) * MAX_SHADERS); + memset(e_data.transparent_accum_sh_cache, 0x00, sizeof(struct GPUShader *) * MAX_SHADERS); + + char *defines = workbench_material_build_defines(wpd, OB_SOLID, false); + char *defines_hair = workbench_material_build_defines(wpd, OB_SOLID, true); + char *forward_vert = workbench_build_forward_vert(); + char *forward_depth_frag = workbench_build_forward_depth_frag(); + e_data.object_outline_sh = DRW_shader_create( + forward_vert, NULL, + forward_depth_frag, defines); + e_data.object_outline_hair_sh = DRW_shader_create( + forward_vert, NULL, + forward_depth_frag, defines_hair); + + e_data.checker_depth_sh = DRW_shader_create_fullscreen( + datatoc_workbench_checkerboard_depth_frag_glsl, NULL); + MEM_freeN(forward_vert); + MEM_freeN(forward_depth_frag); + MEM_freeN(defines); + MEM_freeN(defines_hair); + } + select_forward_shaders(wpd); + + const float *viewport_size = DRW_viewport_size_get(); + const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]}; + + e_data.object_id_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_R32UI, &draw_engine_workbench_transparent); + e_data.transparent_accum_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_RGBA16F, &draw_engine_workbench_transparent); + e_data.transparent_revealage_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_R16F, &draw_engine_workbench_transparent); + e_data.composite_buffer_tx = DRW_texture_pool_query_2D( + size[0], size[1], GPU_R11F_G11F_B10F, &draw_engine_workbench_transparent); + + GPU_framebuffer_ensure_config(&fbl->object_outline_fb, { + GPU_ATTACHMENT_TEXTURE(dtxl->depth), + GPU_ATTACHMENT_TEXTURE(e_data.object_id_tx), + }); + + GPU_framebuffer_ensure_config(&fbl->transparent_accum_fb, { + GPU_ATTACHMENT_NONE, + GPU_ATTACHMENT_TEXTURE(e_data.transparent_accum_tx), + GPU_ATTACHMENT_TEXTURE(e_data.transparent_revealage_tx), + }); + + GPU_framebuffer_ensure_config(&fbl->composite_fb, { + GPU_ATTACHMENT_NONE, + GPU_ATTACHMENT_TEXTURE(e_data.composite_buffer_tx), + }); + + /* Transparency Accum */ + { + int state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_OIT; + psl->transparent_accum_pass = DRW_pass_create("Transparent Accum", state); + } + /* Depth */ + { + int state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS; + psl->object_outline_pass = DRW_pass_create("Object Outline Pass", state); + } + /* Composite */ + { + int state = DRW_STATE_WRITE_COLOR; + psl->composite_pass = DRW_pass_create("Composite", state); + + grp = DRW_shgroup_create(wpd->composite_sh, psl->composite_pass); + if (OBJECT_ID_PASS_ENABLED(wpd)) { + DRW_shgroup_uniform_texture_ref(grp, "objectId", &e_data.object_id_tx); + } + DRW_shgroup_uniform_texture_ref(grp, "transparentAccum", &e_data.transparent_accum_tx); + DRW_shgroup_uniform_texture_ref(grp, "transparentRevealage", &e_data.transparent_revealage_tx); + DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo); + DRW_shgroup_uniform_vec2(grp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + } + /* Checker Depth */ + { + int state = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS; + psl->checker_depth_pass = DRW_pass_create("Checker Depth", state); + grp = DRW_shgroup_create(e_data.checker_depth_sh, psl->checker_depth_pass); + DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL); + DRW_shgroup_uniform_float_copy(grp, "threshold", 0.75f - wpd->shading.xray_alpha * 0.5f); + } +} + +void workbench_forward_engine_free() +{ + for (int index = 0; index < MAX_SHADERS; index++) { + DRW_SHADER_FREE_SAFE(e_data.composite_sh_cache[index]); + DRW_SHADER_FREE_SAFE(e_data.transparent_accum_sh_cache[index]); + } + DRW_SHADER_FREE_SAFE(e_data.object_outline_sh); + DRW_SHADER_FREE_SAFE(e_data.object_outline_hair_sh); + DRW_SHADER_FREE_SAFE(e_data.checker_depth_sh); +} + +void workbench_forward_cache_init(WORKBENCH_Data *UNUSED(vedata)) +{ +} + +static void workbench_forward_cache_populate_particles(WORKBENCH_Data *vedata, Object *ob) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_PrivateData *wpd = stl->g_data; + const DRWContextState *draw_ctx = DRW_context_state_get(); + + if (ob == draw_ctx->object_edit) { + return; + } + for (ModifierData *md = ob->modifiers.first; md; md = md->next) { + if (md->type != eModifierType_ParticleSystem) { + continue; + } + ParticleSystem *psys = ((ParticleSystemModifierData *)md)->psys; + if (!psys_check_enabled(ob, psys, false)) { + continue; + } + if (!DRW_check_psys_visible_within_active_context(ob, psys)) { + continue; + } + ParticleSettings *part = psys->part; + const int draw_as = (part->draw_as == PART_DRAW_REND) ? part->ren_as : part->draw_as; + + if (draw_as == PART_DRAW_PATH) { + Image *image = NULL; + Material *mat = give_current_material(ob, part->omat); + ED_object_get_active_image(ob, part->omat, &image, NULL, NULL, NULL); + int color_type = workbench_material_determine_color_type(wpd, image); + WORKBENCH_MaterialData *material = get_or_create_material_data(vedata, ob, mat, image, color_type); + + struct GPUShader *shader = (color_type != V3D_SHADING_TEXTURE_COLOR) + ? wpd->transparent_accum_hair_sh + : wpd->transparent_accum_texture_hair_sh; + DRWShadingGroup *shgrp = DRW_shgroup_hair_create( + ob, psys, md, + psl->transparent_accum_pass, + shader); + workbench_material_set_normal_world_matrix(shgrp, wpd, e_data.normal_world_matrix); + DRW_shgroup_uniform_block(shgrp, "world_block", wpd->world_ubo); + DRW_shgroup_uniform_block(shgrp, "material_block", material->material_ubo); + DRW_shgroup_uniform_vec4(shgrp, "viewvecs[0]", (float *)wpd->viewvecs, 3); + /* Hairs have lots of layer and can rapidly become the most prominent surface. + * So lower their alpha artificially. */ + float hair_alpha = wpd->shading.xray_alpha * 0.33f; + DRW_shgroup_uniform_float_copy(shgrp, "alpha", hair_alpha); + if (image) { + GPUTexture *tex = GPU_texture_from_blender(image, NULL, GL_TEXTURE_2D, false, 0.0f); + DRW_shgroup_uniform_texture(shgrp, "image", tex); + } + if (STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd)) { + BKE_studiolight_ensure_flag(wpd->studio_light, STUDIOLIGHT_EQUIRECTANGULAR_RADIANCE_GPUTEXTURE); + DRW_shgroup_uniform_texture(shgrp, "matcapImage", wpd->studio_light->equirectangular_radiance_gputexture); + } + if (SPECULAR_HIGHLIGHT_ENABLED(wpd) || MATCAP_ENABLED(wpd)) { + DRW_shgroup_uniform_vec2(shgrp, "invertedViewportSize", DRW_viewport_invert_size_get(), 1); + } + shgrp = DRW_shgroup_hair_create(ob, psys, md, + vedata->psl->object_outline_pass, + e_data.object_outline_hair_sh); + DRW_shgroup_uniform_int(shgrp, "object_id", &material->object_id, 1); + } + } +} + +void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob) +{ + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_PrivateData *wpd = stl->g_data; + + if (!DRW_object_is_renderable(ob)) + return; + + if (ob->type == OB_MESH) { + workbench_forward_cache_populate_particles(vedata, ob); + } + + if (!DRW_check_object_visible_within_active_context(ob)) { + return; + } + + WORKBENCH_MaterialData *material; + if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) { + const DRWContextState *draw_ctx = DRW_context_state_get(); + const bool is_active = (ob == draw_ctx->obact); + const bool is_sculpt_mode = is_active && (draw_ctx->object_mode & OB_MODE_SCULPT) != 0; + bool is_drawn = false; + + if (!is_sculpt_mode && TEXTURE_DRAWING_ENABLED(wpd) && ELEM(ob->type, OB_MESH)) { + const Mesh *me = ob->data; + if (me->mloopuv) { + const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol)); + struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len); + struct Gwn_Batch **geom_array = me->totcol ? DRW_cache_mesh_surface_texpaint_get(ob) : NULL; + if (materials_len > 0 && geom_array) { + for (int i = 0; i < materials_len; i++) { + if (geom_array[i] == NULL) { + continue; + } + + Material *mat = give_current_material(ob, i + 1); + Image *image; + ED_object_get_active_image(ob, i + 1, &image, NULL, NULL, NULL); + /* use OB_SOLID when no texture could be determined */ + + int color_type = wpd->shading.color_type; + if (color_type == V3D_SHADING_TEXTURE_COLOR) { + /* use OB_SOLID when no texture could be determined */ + if (image == NULL) { + color_type = V3D_SHADING_MATERIAL_COLOR; + } + } + + material = get_or_create_material_data(vedata, ob, mat, image, color_type); + DRW_shgroup_call_object_add(material->shgrp_object_outline, geom_array[i], ob); + DRW_shgroup_call_object_add(material->shgrp, geom_array[i], ob); + } + is_drawn = true; + } + } + } + + /* Fallback from not drawn OB_TEXTURE mode or just OB_SOLID mode */ + if (!is_drawn) { + if (ELEM(wpd->shading.color_type, V3D_SHADING_SINGLE_COLOR, V3D_SHADING_RANDOM_COLOR)) { + /* No material split needed */ + struct Gwn_Batch *geom = DRW_cache_object_surface_get(ob); + if (geom) { + material = get_or_create_material_data(vedata, ob, NULL, NULL, wpd->shading.color_type); + if (is_sculpt_mode) { + DRW_shgroup_call_sculpt_add(material->shgrp_object_outline, ob, ob->obmat); + DRW_shgroup_call_sculpt_add(material->shgrp, ob, ob->obmat); + } + else { + DRW_shgroup_call_object_add(material->shgrp_object_outline, geom, ob); + DRW_shgroup_call_object_add(material->shgrp, geom, ob); + } + } + } + else { + const int materials_len = MAX2(1, (is_sculpt_mode ? 1 : ob->totcol)); + struct GPUMaterial **gpumat_array = BLI_array_alloca(gpumat_array, materials_len); + for (int i = 0; i < materials_len; i++) { + gpumat_array[i] = NULL; + } + + struct Gwn_Batch **mat_geom = DRW_cache_object_surface_material_get( + ob, gpumat_array, materials_len, NULL, NULL, NULL); + if (mat_geom) { + for (int i = 0; i < materials_len; ++i) { + if (mat_geom[i] == NULL) { + continue; + } + + Material *mat = give_current_material(ob, i + 1); + material = get_or_create_material_data(vedata, ob, mat, NULL, V3D_SHADING_MATERIAL_COLOR); + if (is_sculpt_mode) { + DRW_shgroup_call_sculpt_add(material->shgrp_object_outline, ob, ob->obmat); + DRW_shgroup_call_sculpt_add(material->shgrp, ob, ob->obmat); + } + else { + DRW_shgroup_call_object_add(material->shgrp_object_outline, mat_geom[i], ob); + DRW_shgroup_call_object_add(material->shgrp, mat_geom[i], ob); + } + } + } + } + } + } +} + +void workbench_forward_cache_finish(WORKBENCH_Data *UNUSED(vedata)) +{ +} + +void workbench_forward_draw_background(WORKBENCH_Data *UNUSED(vedata)) +{ + const float clear_depth = 1.0f; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + DRW_stats_group_start("Clear depth"); + GPU_framebuffer_bind(dfbl->default_fb); + GPU_framebuffer_clear_depth(dfbl->default_fb, clear_depth); + DRW_stats_group_end(); +} + +void workbench_forward_draw_scene(WORKBENCH_Data *vedata) +{ + WORKBENCH_PassList *psl = vedata->psl; + WORKBENCH_StorageList *stl = vedata->stl; + WORKBENCH_FramebufferList *fbl = vedata->fbl; + WORKBENCH_PrivateData *wpd = stl->g_data; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + + /* Write Depth + Object ID */ + const float clear_outline[4] = {0.0f}; + GPU_framebuffer_bind(fbl->object_outline_fb); + GPU_framebuffer_clear_color(fbl->object_outline_fb, clear_outline); + DRW_draw_pass(psl->object_outline_pass); + + if (wpd->shading.xray_alpha > 0.0) { + const float clear_color[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + GPU_framebuffer_bind(fbl->transparent_accum_fb); + GPU_framebuffer_clear_color(fbl->transparent_accum_fb, clear_color); + DRW_draw_pass(psl->transparent_accum_pass); + } + else { + /* TODO(fclem): this is unecessary and takes up perf. + * Better change the composite frag shader to not use the tx. */ + const float clear_color[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + GPU_framebuffer_bind(fbl->transparent_accum_fb); + GPU_framebuffer_clear_color(fbl->transparent_accum_fb, clear_color); + } + + /* Composite */ + GPU_framebuffer_bind(fbl->composite_fb); + DRW_draw_pass(psl->composite_pass); + + /* Color correct */ + GPU_framebuffer_bind(dfbl->color_only_fb); + DRW_transform_to_display(e_data.composite_buffer_tx); + + GPU_framebuffer_bind(dfbl->depth_only_fb); + DRW_draw_pass(psl->checker_depth_pass); + + workbench_private_data_free(wpd); +} diff --git a/source/blender/draw/engines/workbench/workbench_materials.c b/source/blender/draw/engines/workbench/workbench_materials.c new file mode 100644 index 00000000000..76599fdce99 --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_materials.c @@ -0,0 +1,176 @@ + + +#include "workbench_private.h" + +#include "BLI_dynstr.h" + +#define HSV_SATURATION 0.5 +#define HSV_VALUE 0.9 + +void workbench_material_update_data(WORKBENCH_PrivateData *wpd, Object *ob, Material *mat, WORKBENCH_MaterialData *data) +{ + /* When V3D_SHADING_TEXTURE_COLOR is active, use V3D_SHADING_MATERIAL_COLOR as fallback when no texture could be determined */ + int color_type = wpd->shading.color_type == V3D_SHADING_TEXTURE_COLOR ? V3D_SHADING_MATERIAL_COLOR : wpd->shading.color_type; + static float default_diffuse_color[] = {0.8f, 0.8f, 0.8f, 1.0f}; + static float default_specular_color[] = {0.5f, 0.5f, 0.5f, 0.5f}; + copy_v4_v4(data->material_data.diffuse_color, default_diffuse_color); + copy_v4_v4(data->material_data.specular_color, default_specular_color); + data->material_data.roughness = 0.5f; + + if (color_type == V3D_SHADING_SINGLE_COLOR) { + copy_v3_v3(data->material_data.diffuse_color, wpd->shading.single_color); + } + else if (color_type == V3D_SHADING_RANDOM_COLOR) { + uint hash = BLI_ghashutil_strhash_p_murmur(ob->id.name); + if (ob->id.lib) { + hash = (hash * 13) ^ BLI_ghashutil_strhash_p_murmur(ob->id.lib->name); + } + float offset = fmodf((hash / 100000.0) * M_GOLDEN_RATION_CONJUGATE, 1.0); + + float hsv[3] = {offset, HSV_SATURATION, HSV_VALUE}; + hsv_to_rgb_v(hsv, data->material_data.diffuse_color); + } + else { + /* V3D_SHADING_MATERIAL_COLOR */ + if (mat) { + copy_v3_v3(data->material_data.diffuse_color, &mat->r); + copy_v3_v3(data->material_data.specular_color, &mat->specr); + data->material_data.roughness = mat->roughness; + } + } +} + +char *workbench_material_build_defines(WORKBENCH_PrivateData *wpd, bool use_textures, bool is_hair) +{ + char *str = NULL; + + DynStr *ds = BLI_dynstr_new(); + + if (wpd->shading.flag & V3D_SHADING_OBJECT_OUTLINE) { + BLI_dynstr_appendf(ds, "#define V3D_SHADING_OBJECT_OUTLINE\n"); + } + if (wpd->shading.flag & V3D_SHADING_SHADOW) { + BLI_dynstr_appendf(ds, "#define V3D_SHADING_SHADOW\n"); + } + if (CAVITY_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define V3D_SHADING_CAVITY\n"); + } + if (SPECULAR_HIGHLIGHT_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define V3D_SHADING_SPECULAR_HIGHLIGHT\n"); + } + if (STUDIOLIGHT_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define V3D_LIGHTING_STUDIO\n"); + } + if (FLAT_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define V3D_LIGHTING_FLAT\n"); + } + if (MATCAP_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define V3D_LIGHTING_MATCAP\n"); + } + if (STUDIOLIGHT_ORIENTATION_WORLD_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_ORIENTATION_WORLD\n"); + } + if (STUDIOLIGHT_ORIENTATION_CAMERA_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_ORIENTATION_CAMERA\n"); + } + if (STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_ORIENTATION_VIEWNORMAL\n"); + } + if (NORMAL_VIEWPORT_PASS_ENABLED(wpd)) { + BLI_dynstr_appendf(ds, "#define NORMAL_VIEWPORT_PASS_ENABLED\n"); + } + if (use_textures) { + BLI_dynstr_appendf(ds, "#define V3D_SHADING_TEXTURE_COLOR\n"); + } + if (NORMAL_ENCODING_ENABLED()) { + BLI_dynstr_appendf(ds, "#define WORKBENCH_ENCODE_NORMALS\n"); + } + if (is_hair) { + BLI_dynstr_appendf(ds, "#define HAIR_SHADER\n"); + } + +#if STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL == 0 + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL 0\n"); +#endif +#if STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL == 1 + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL 1\n"); +#endif +#if STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL == 2 + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_SPHERICAL_HARMONICS_LEVEL 2\n"); +#endif + BLI_dynstr_appendf(ds, "#define STUDIOLIGHT_SPHERICAL_HARMONICS_MAX_COMPONENTS 9\n"); + + str = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + return str; +} + +uint workbench_material_get_hash(WORKBENCH_MaterialData *material_template) +{ + uint input[4]; + uint result; + float *color = material_template->material_data.diffuse_color; + input[0] = (uint)(color[0] * 512); + input[1] = (uint)(color[1] * 512); + input[2] = (uint)(color[2] * 512); + input[3] = material_template->object_id; + result = BLI_ghashutil_uinthash_v4_murmur(input); + + color = material_template->material_data.specular_color; + input[0] = (uint)(color[0] * 512); + input[1] = (uint)(color[1] * 512); + input[2] = (uint)(color[2] * 512); + input[3] = (uint)(material_template->material_data.roughness * 512); + result += BLI_ghashutil_uinthash_v4_murmur(input); + + if (material_template->color_type == V3D_SHADING_TEXTURE_COLOR) { + /* add texture reference */ + result += BLI_ghashutil_inthash_p_murmur(material_template->ima); + } + return result; +} + +int workbench_material_get_shader_index(WORKBENCH_PrivateData *wpd, bool use_textures, bool is_hair) +{ + /* NOTE: change MAX_SHADERS accordingly when modifying this function. */ + int index = 0; + /* 1 bit V3D_SHADING_TEXTURE_COLOR */ + SET_FLAG_FROM_TEST(index, use_textures, 1 << 0); + /* 2 bits FLAT/STUDIO/MATCAP/SCENE */ + SET_FLAG_FROM_TEST(index, wpd->shading.light, wpd->shading.light << 1); + /* 1 bit V3D_SHADING_SPECULAR_HIGHLIGHT */ + SET_FLAG_FROM_TEST(index, wpd->shading.flag & V3D_SHADING_SPECULAR_HIGHLIGHT, 1 << 3); + SET_FLAG_FROM_TEST(index, wpd->shading.flag & V3D_SHADING_SHADOW, 1 << 4); + SET_FLAG_FROM_TEST(index, wpd->shading.flag & V3D_SHADING_CAVITY, 1 << 5); + SET_FLAG_FROM_TEST(index, wpd->shading.flag & V3D_SHADING_OBJECT_OUTLINE, 1 << 6); + /* 2 bits STUDIOLIGHT_ORIENTATION */ + SET_FLAG_FROM_TEST(index, wpd->studio_light->flag & STUDIOLIGHT_ORIENTATION_WORLD, 1 << 7); + SET_FLAG_FROM_TEST(index, wpd->studio_light->flag & STUDIOLIGHT_ORIENTATION_VIEWNORMAL, 1 << 8); + /* 1 bit for hair */ + SET_FLAG_FROM_TEST(index, is_hair, 1 << 9); + return index; +} + +void workbench_material_set_normal_world_matrix( + DRWShadingGroup *grp, WORKBENCH_PrivateData *wpd, float persistent_matrix[3][3]) +{ + if (STUDIOLIGHT_ORIENTATION_WORLD_ENABLED(wpd)) { + float view_matrix_inverse[4][4]; + float rot_matrix[4][4]; + float matrix[4][4]; + axis_angle_to_mat4_single(rot_matrix, 'Z', -wpd->shading.studiolight_rot_z); + DRW_viewport_matrix_get(view_matrix_inverse, DRW_MAT_VIEWINV); + mul_m4_m4m4(matrix, rot_matrix, view_matrix_inverse); + copy_m3_m4(persistent_matrix, matrix); + DRW_shgroup_uniform_mat3(grp, "normalWorldMatrix", persistent_matrix); + } +} + +int workbench_material_determine_color_type(WORKBENCH_PrivateData *wpd, Image *ima) +{ + int color_type = wpd->shading.color_type; + if (color_type == V3D_SHADING_TEXTURE_COLOR && ima == NULL) { + color_type = V3D_SHADING_MATERIAL_COLOR; + } + return color_type; +} diff --git a/source/blender/draw/engines/workbench/workbench_private.h b/source/blender/draw/engines/workbench/workbench_private.h new file mode 100644 index 00000000000..57cfd6b4718 --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_private.h @@ -0,0 +1,255 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_private.h + * \ingroup draw_engine + */ + +#ifndef __WORKBENCH_PRIVATE_H__ +#define __WORKBENCH_PRIVATE_H__ + + +#include "BKE_studiolight.h" + +#include "DNA_image_types.h" +#include "DNA_view3d_types.h" +#include "DNA_world_types.h" +#include "DNA_userdef_types.h" + +#include "DRW_render.h" + + +#define WORKBENCH_ENGINE "BLENDER_WORKBENCH" +#define M_GOLDEN_RATION_CONJUGATE 0.618033988749895 +#define MAX_SHADERS (1 << 10) + +#define TEXTURE_DRAWING_ENABLED(wpd) (wpd->color_type & V3D_SHADING_TEXTURE_COLOR) +#define FLAT_ENABLED(wpd) (wpd->shading.light == V3D_LIGHTING_FLAT) +#define STUDIOLIGHT_ENABLED(wpd) (wpd->shading.light == V3D_LIGHTING_STUDIO) +#define MATCAP_ENABLED(wpd) (wpd->shading.light == V3D_LIGHTING_MATCAP) +#define STUDIOLIGHT_ORIENTATION_WORLD_ENABLED(wpd) (STUDIOLIGHT_ENABLED(wpd) && (wpd->studio_light->flag & STUDIOLIGHT_ORIENTATION_WORLD)) +#define STUDIOLIGHT_ORIENTATION_CAMERA_ENABLED(wpd) (STUDIOLIGHT_ENABLED(wpd) && (wpd->studio_light->flag & STUDIOLIGHT_ORIENTATION_CAMERA)) +#define STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd) (MATCAP_ENABLED(wpd) && (wpd->studio_light->flag & STUDIOLIGHT_ORIENTATION_VIEWNORMAL)) +#define CAVITY_ENABLED(wpd) (wpd->shading.flag & V3D_SHADING_CAVITY) +#define SHADOW_ENABLED(wpd) (wpd->shading.flag & V3D_SHADING_SHADOW) +#define FXAA_ENABLED(wpd) (wpd->user_preferences->gpu_viewport_antialias & USER_AA_FXAA && (!DRW_state_is_opengl_render())) +#define SPECULAR_HIGHLIGHT_ENABLED(wpd) ((wpd->shading.flag & V3D_SHADING_SPECULAR_HIGHLIGHT) && (!STUDIOLIGHT_ORIENTATION_VIEWNORMAL_ENABLED(wpd))) +#define OBJECT_ID_PASS_ENABLED(wpd) (wpd->shading.flag & V3D_SHADING_OBJECT_OUTLINE) +#define NORMAL_VIEWPORT_COMP_PASS_ENABLED(wpd) (MATCAP_ENABLED(wpd) || STUDIOLIGHT_ENABLED(wpd) || SHADOW_ENABLED(wpd) || SPECULAR_HIGHLIGHT_ENABLED(wpd)) +#define NORMAL_VIEWPORT_PASS_ENABLED(wpd) (NORMAL_VIEWPORT_COMP_PASS_ENABLED(wpd) || CAVITY_ENABLED(wpd)) +#define NORMAL_ENCODING_ENABLED() (true) +#define TEXTURE_DRAWING_ENABLED(wpd) (wpd->color_type & V3D_SHADING_TEXTURE_COLOR) + + +typedef struct WORKBENCH_FramebufferList { + /* Deferred render buffers */ + struct GPUFrameBuffer *prepass_fb; + struct GPUFrameBuffer *cavity_fb; + struct GPUFrameBuffer *composite_fb; + struct GPUFrameBuffer *effect_fb; + + /* Forward render buffers */ + struct GPUFrameBuffer *object_outline_fb; + struct GPUFrameBuffer *transparent_accum_fb; + struct GPUFrameBuffer *transparent_revealage_fb; +} WORKBENCH_FramebufferList; + +typedef struct WORKBENCH_StorageList { + struct WORKBENCH_PrivateData *g_data; +} WORKBENCH_StorageList; + +typedef struct WORKBENCH_PassList { + /* deferred rendering */ + struct DRWPass *prepass_pass; + struct DRWPass *prepass_hair_pass; + struct DRWPass *cavity_pass; + struct DRWPass *shadow_depth_pass_pass; + struct DRWPass *shadow_depth_pass_mani_pass; + struct DRWPass *shadow_depth_fail_pass; + struct DRWPass *shadow_depth_fail_mani_pass; + struct DRWPass *shadow_depth_fail_caps_pass; + struct DRWPass *shadow_depth_fail_caps_mani_pass; + struct DRWPass *composite_pass; + struct DRWPass *composite_shadow_pass; + struct DRWPass *effect_fxaa_pass; + + /* forward rendering */ + struct DRWPass *transparent_accum_pass; + struct DRWPass *object_outline_pass; + struct DRWPass *depth_pass; + struct DRWPass *checker_depth_pass; +} WORKBENCH_PassList; + +typedef struct WORKBENCH_Data { + void *engine_type; + WORKBENCH_FramebufferList *fbl; + DRWViewportEmptyList *txl; + WORKBENCH_PassList *psl; + WORKBENCH_StorageList *stl; +} WORKBENCH_Data; + +typedef struct WORKBENCH_UBO_Light { + float light_direction_vs[4]; + float specular_color[3]; + float energy; +} WORKBENCH_UBO_Light; + +typedef struct WORKBENCH_UBO_World { + float spherical_harmonics_coefs[STUDIOLIGHT_SPHERICAL_HARMONICS_MAX_COMPONENTS][4]; + float background_color_low[4]; + float background_color_high[4]; + float object_outline_color[4]; + float light_direction_vs[4]; + WORKBENCH_UBO_Light lights[3]; + int num_lights; + int matcap_orientation; + float background_alpha; + int pad[1]; +} WORKBENCH_UBO_World; +BLI_STATIC_ASSERT_ALIGN(WORKBENCH_UBO_World, 16) + +typedef struct WORKBENCH_UBO_Material { + float diffuse_color[4]; + float specular_color[4]; + float roughness; + float pad[3]; +} WORKBENCH_UBO_Material; +BLI_STATIC_ASSERT_ALIGN(WORKBENCH_UBO_Material, 16) + +typedef struct WORKBENCH_PrivateData { + struct GHash *material_hash; + struct GPUShader *prepass_solid_sh; + struct GPUShader *prepass_solid_hair_sh; + struct GPUShader *prepass_texture_sh; + struct GPUShader *prepass_texture_hair_sh; + struct GPUShader *composite_sh; + struct GPUShader *transparent_accum_sh; + struct GPUShader *transparent_accum_hair_sh; + struct GPUShader *transparent_accum_texture_sh; + struct GPUShader *transparent_accum_texture_hair_sh; + View3DShading shading; + StudioLight *studio_light; + UserDef *user_preferences; + int color_type; + struct GPUUniformBuffer *world_ubo; + struct DRWShadingGroup *shadow_shgrp; + struct DRWShadingGroup *depth_shgrp; + WORKBENCH_UBO_World world_data; + float shadow_multiplier; + float cached_shadow_direction[3]; + float shadow_mat[4][4]; + float shadow_inv[4][4]; + float shadow_far_plane[4]; /* Far plane of the view frustum. */ + float shadow_near_corners[4][3]; /* Near plane corners in shadow space. */ + float shadow_near_min[3]; /* min and max of shadow_near_corners. allow fast test */ + float shadow_near_max[3]; + float shadow_near_sides[2][4]; /* This is a parallelogram, so only 2 normal and distance to the edges. */ + bool shadow_changed; + + /* Ssao */ + float winmat[4][4]; + float viewvecs[3][4]; + float ssao_params[4]; + float ssao_settings[4]; +} WORKBENCH_PrivateData; /* Transient data */ + +typedef struct WORKBENCH_MaterialData { + /* Solid color */ + WORKBENCH_UBO_Material material_data; + struct GPUUniformBuffer *material_ubo; + + int object_id; + int color_type; + Image *ima; + + /* Linked shgroup for drawing */ + DRWShadingGroup *shgrp; + /* forward rendering */ + DRWShadingGroup *shgrp_object_outline; +} WORKBENCH_MaterialData; + +typedef struct WORKBENCH_ObjectData { + struct ObjectEngineData *next, *prev; + struct DrawEngineType *engine_type; + /* Only nested data, NOT the engine data itself. */ + ObjectEngineDataFreeCb free; + /* Accumulated recalc flags, which corresponds to ID->recalc flags. */ + int recalc; + /* Shadow direction in local object space. */ + float shadow_dir[3], shadow_depth; + float shadow_min[3], shadow_max[3]; /* Min, max in shadow space */ + BoundBox shadow_bbox; + bool shadow_bbox_dirty; + + int object_id; +} WORKBENCH_ObjectData; + +/* workbench_engine.c */ +void workbench_solid_materials_init(WORKBENCH_Data *vedata); +void workbench_solid_materials_cache_init(WORKBENCH_Data *vedata); +void workbench_solid_materials_cache_populate(WORKBENCH_Data *vedata, Object *ob); +void workbench_solid_materials_cache_finish(WORKBENCH_Data *vedata); +void workbench_solid_materials_draw_scene(WORKBENCH_Data *vedata); +void workbench_solid_materials_free(void); + +/* workbench_deferred.c */ +void workbench_deferred_engine_init(WORKBENCH_Data *vedata); +void workbench_deferred_engine_free(void); +void workbench_deferred_draw_background(WORKBENCH_Data *vedata); +void workbench_deferred_draw_scene(WORKBENCH_Data *vedata); +void workbench_deferred_cache_init(WORKBENCH_Data *vedata); +void workbench_deferred_solid_cache_populate(WORKBENCH_Data *vedata, Object *ob); +void workbench_deferred_cache_finish(WORKBENCH_Data *vedata); + +/* workbench_forward.c */ +void workbench_forward_engine_init(WORKBENCH_Data *vedata); +void workbench_forward_engine_free(void); +void workbench_forward_draw_background(WORKBENCH_Data *vedata); +void workbench_forward_draw_scene(WORKBENCH_Data *vedata); +void workbench_forward_cache_init(WORKBENCH_Data *vedata); +void workbench_forward_cache_populate(WORKBENCH_Data *vedata, Object *ob); +void workbench_forward_cache_finish(WORKBENCH_Data *vedata); + +/* workbench_materials.c */ +int workbench_material_determine_color_type(WORKBENCH_PrivateData *wpd, Image *ima); +char *workbench_material_build_defines(WORKBENCH_PrivateData *wpd, bool use_textures, bool is_hair); +void workbench_material_update_data(WORKBENCH_PrivateData *wpd, Object *ob, Material *mat, WORKBENCH_MaterialData *data); +uint workbench_material_get_hash(WORKBENCH_MaterialData *material_template); +int workbench_material_get_shader_index(WORKBENCH_PrivateData *wpd, bool use_textures, bool is_hair); +void workbench_material_set_normal_world_matrix( + DRWShadingGroup *grp, WORKBENCH_PrivateData *wpd, float persistent_matrix[3][3]); + +/* workbench_studiolight.c */ +void studiolight_update_world(StudioLight *sl, WORKBENCH_UBO_World *wd); +void studiolight_update_light(WORKBENCH_PrivateData *wpd, const float light_direction[3]); +bool studiolight_object_cast_visible_shadow(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed); +float studiolight_object_shadow_distance(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed); +bool studiolight_camera_in_object_shadow(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed); + +/* workbench_data.c */ +void workbench_private_data_init(WORKBENCH_PrivateData *wpd); +void workbench_private_data_free(WORKBENCH_PrivateData *wpd); +void workbench_private_data_get_light_direction(WORKBENCH_PrivateData *wpd, float light_direction[3]); + +extern DrawEngineType draw_engine_workbench_solid; +extern DrawEngineType draw_engine_workbench_transparent; + +#endif diff --git a/source/blender/draw/engines/workbench/workbench_studiolight.c b/source/blender/draw/engines/workbench/workbench_studiolight.c new file mode 100644 index 00000000000..f9e5df91388 --- /dev/null +++ b/source/blender/draw/engines/workbench/workbench_studiolight.c @@ -0,0 +1,212 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file workbench_studiolight.c + * \ingroup draw_engine + */ +#include "BKE_studiolight.h" + +#include "DRW_engine.h" +#include "workbench_private.h" + +#include "BKE_object.h" + +#include "BLI_math.h" +#include "BKE_global.h" + +void studiolight_update_world(StudioLight *sl, WORKBENCH_UBO_World *wd) +{ + int i; + BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_SPHERICAL_HARMONICS_COEFFICIENTS_CALCULATED); + + for (i = 0; i < STUDIOLIGHT_SPHERICAL_HARMONICS_COMPONENTS; i++) { + copy_v3_v3(wd->spherical_harmonics_coefs[i], sl->spherical_harmonics_coefs[i]); + } + for (; i < STUDIOLIGHT_SPHERICAL_HARMONICS_MAX_COMPONENTS; i++) { + copy_v3_fl(wd->spherical_harmonics_coefs[i], 0.0); + } +} + +static void compute_parallel_lines_nor_and_dist(const float v1[2], const float v2[2], const float v3[2], float r_line[2]) +{ + sub_v2_v2v2(r_line, v2, v1); + /* Find orthogonal vector. */ + SWAP(float, r_line[0], r_line[1]); + r_line[0] = -r_line[0]; + /* Edge distances. */ + r_line[2] = dot_v2v2(r_line, v1); + r_line[3] = dot_v2v2(r_line, v3); + /* Make sure r_line[2] is the minimum. */ + if (r_line[2] > r_line[3]) { + SWAP(float, r_line[2], r_line[3]); + } +} + +void studiolight_update_light(WORKBENCH_PrivateData *wpd, const float light_direction[3]) +{ + wpd->shadow_changed = !compare_v3v3(wpd->cached_shadow_direction, light_direction, 1e-5f); + + if (wpd->shadow_changed) { + float up[3] = {0.0f, 0.0f, 1.0f}; + unit_m4(wpd->shadow_mat); + + /* TODO fix singularity. */ + copy_v3_v3(wpd->shadow_mat[2], light_direction); + cross_v3_v3v3(wpd->shadow_mat[0], wpd->shadow_mat[2], up); + normalize_v3(wpd->shadow_mat[0]); + cross_v3_v3v3(wpd->shadow_mat[1], wpd->shadow_mat[2], wpd->shadow_mat[0]); + + invert_m4_m4(wpd->shadow_inv, wpd->shadow_mat); + + copy_v3_v3(wpd->cached_shadow_direction, light_direction); + } + + float planes[6][4]; + DRW_culling_frustum_planes_get(planes); + /* we only need the far plane. */ + copy_v4_v4(wpd->shadow_far_plane, planes[2]); + + BoundBox frustum_corners; + DRW_culling_frustum_corners_get(&frustum_corners); + + mul_v3_mat3_m4v3(wpd->shadow_near_corners[0], wpd->shadow_inv, frustum_corners.vec[0]); + mul_v3_mat3_m4v3(wpd->shadow_near_corners[1], wpd->shadow_inv, frustum_corners.vec[3]); + mul_v3_mat3_m4v3(wpd->shadow_near_corners[2], wpd->shadow_inv, frustum_corners.vec[7]); + mul_v3_mat3_m4v3(wpd->shadow_near_corners[3], wpd->shadow_inv, frustum_corners.vec[4]); + + INIT_MINMAX(wpd->shadow_near_min, wpd->shadow_near_max); + for (int i = 0; i < 4; ++i) { + minmax_v3v3_v3(wpd->shadow_near_min, wpd->shadow_near_max, wpd->shadow_near_corners[i]); + } + + compute_parallel_lines_nor_and_dist(wpd->shadow_near_corners[0], wpd->shadow_near_corners[1], wpd->shadow_near_corners[2], wpd->shadow_near_sides[0]); + compute_parallel_lines_nor_and_dist(wpd->shadow_near_corners[1], wpd->shadow_near_corners[2], wpd->shadow_near_corners[0], wpd->shadow_near_sides[1]); +} + +static BoundBox *studiolight_object_shadow_bbox_get(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed) +{ + if ((oed->shadow_bbox_dirty) || (wpd->shadow_changed)) { + float tmp_mat[4][4]; + mul_m4_m4m4(tmp_mat, wpd->shadow_inv, ob->obmat); + + /* Get AABB in shadow space. */ + INIT_MINMAX(oed->shadow_min, oed->shadow_max); + + /* From object space to shadow space */ + BoundBox *bbox = BKE_object_boundbox_get(ob); + for (int i = 0; i < 8; ++i) { + float corner[3]; + mul_v3_m4v3(corner, tmp_mat, bbox->vec[i]); + minmax_v3v3_v3(oed->shadow_min, oed->shadow_max, corner); + } + oed->shadow_depth = oed->shadow_max[2] - oed->shadow_min[2]; + /* Extend towards infinity. */ + oed->shadow_max[2] += 1e4f; + + /* Get extended AABB in world space. */ + BKE_boundbox_init_from_minmax(&oed->shadow_bbox, oed->shadow_min, oed->shadow_max); + for (int i = 0; i < 8; ++i) { + mul_m4_v3(wpd->shadow_mat, oed->shadow_bbox.vec[i]); + } + oed->shadow_bbox_dirty = false; + } + + return &oed->shadow_bbox; +} + +bool studiolight_object_cast_visible_shadow(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed) +{ + BoundBox *shadow_bbox = studiolight_object_shadow_bbox_get(wpd, ob, oed); + return DRW_culling_box_test(shadow_bbox); +} + +float studiolight_object_shadow_distance(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed) +{ + BoundBox *shadow_bbox = studiolight_object_shadow_bbox_get(wpd, ob, oed); + + int corners[4] = {0, 3, 4, 7}; + float dist = 1e4f, dist_isect; + for (int i = 0; i < 4; ++i) { + if (isect_ray_plane_v3(shadow_bbox->vec[corners[i]], + wpd->cached_shadow_direction, + wpd->shadow_far_plane, + &dist_isect, true)) + { + if (dist_isect < dist) { + dist = dist_isect; + } + } + else { + /* All rays are parallels. If one fails, the other will too. */ + break; + } + } + return max_ii(dist - oed->shadow_depth, 0); +} + +bool studiolight_camera_in_object_shadow(WORKBENCH_PrivateData *wpd, Object *ob, WORKBENCH_ObjectData *oed) +{ + /* Just to be sure the min, max are updated. */ + studiolight_object_shadow_bbox_get(wpd, ob, oed); + + /* Test if near plane is in front of the shadow. */ + if (oed->shadow_min[2] > wpd->shadow_near_max[2]) { + return false; + } + + /* Separation Axis Theorem test */ + + /* Test bbox sides first (faster) */ + if ((oed->shadow_min[0] > wpd->shadow_near_max[0]) || + (oed->shadow_max[0] < wpd->shadow_near_min[0]) || + (oed->shadow_min[1] > wpd->shadow_near_max[1]) || + (oed->shadow_max[1] < wpd->shadow_near_min[1])) + { + return false; + } + + /* Test projected near rectangle sides */ + float pts[4][2] = { + {oed->shadow_min[0], oed->shadow_min[1]}, + {oed->shadow_min[0], oed->shadow_max[1]}, + {oed->shadow_max[0], oed->shadow_min[1]}, + {oed->shadow_max[0], oed->shadow_max[1]} + }; + + for (int i = 0; i < 2; ++i) { + float min_dst = FLT_MAX, max_dst = -FLT_MAX; + for (int j = 0; j < 4; ++j) { + float dst = dot_v2v2(wpd->shadow_near_sides[i], pts[j]); + /* Do min max */ + if (min_dst > dst) min_dst = dst; + if (max_dst < dst) max_dst = dst; + } + + if ((wpd->shadow_near_sides[i][2] > max_dst) || + (wpd->shadow_near_sides[i][3] < min_dst)) + { + return false; + } + } + + /* No separation axis found. Both shape intersect. */ + return true; +} |