14 files changed, 602 insertions, 43 deletions

diff --git a/source/blender/draw/intern/DRW_render.h b/source/blender/draw/intern/DRW_render.h
index 7a889d9399e..3551296cfc3 100644
--- a/source/blender/draw/intern/DRW_render.h
+++ b/source/blender/draw/intern/DRW_render.h
@@ -198,6 +198,17 @@ void DRW_uniformbuffer_free(struct GPUUniformBuffer *ubo);
   } while (0)
 
 /* Shaders */
+
+#ifndef __GPU_MATERIAL_H__
+/* FIXME: Meh avoid including all GPUMaterial. */
+typedef void (*GPUMaterialEvalCallbackFn)(struct GPUMaterial *mat,
+                                          int options,
+                                          const char **vert_code,
+                                          const char **geom_code,
+                                          const char **frag_lib,
+                                          const char **defines);
+#endif
+
 struct GPUShader *DRW_shader_create(const char *vert,
                                     const char *geom,
                                     const char *frag,
@@ -237,7 +248,8 @@ struct GPUMaterial *DRW_shader_create_from_world(struct Scene *scene,
                                                  const char *geom,
                                                  const char *frag_lib,
                                                  const char *defines,
-                                                 bool deferred);
+                                                 bool deferred,
+                                                 GPUMaterialEvalCallbackFn callback);
 struct GPUMaterial *DRW_shader_create_from_material(struct Scene *scene,
                                                     struct Material *ma,
                                                     struct bNodeTree *ntree,
@@ -248,7 +260,8 @@ struct GPUMaterial *DRW_shader_create_from_material(struct Scene *scene,
                                                     const char *geom,
                                                     const char *frag_lib,
                                                     const char *defines,
-                                                    bool deferred);
+                                                    bool deferred,
+                                                    GPUMaterialEvalCallbackFn callback);
 void DRW_shader_free(struct GPUShader *shader);
 #define DRW_SHADER_FREE_SAFE(shader) \
   do { \
diff --git a/source/blender/draw/intern/draw_cache_impl_pointcloud.c b/source/blender/draw/intern/draw_cache_impl_pointcloud.c
index 17902f27513..06cedb9f72c 100644
--- a/source/blender/draw/intern/draw_cache_impl_pointcloud.c
+++ b/source/blender/draw/intern/draw_cache_impl_pointcloud.c
@@ -158,6 +158,7 @@ static void pointcloud_batch_cache_ensure_pos(Object *ob, PointCloudBatchCache *
   const bool has_radius = pointcloud->radius != NULL;
 
   static GPUVertFormat format = {0};
+  static GPUVertFormat format_no_radius = {0};
   static uint pos;
   if (format.attr_len == 0) {
     /* initialize vertex format */
@@ -167,11 +168,11 @@ static void pointcloud_batch_cache_ensure_pos(Object *ob, PointCloudBatchCache *
      * If the vertex shader has more components than the array provides, the extras are given
      * values from the vector (0, 0, 0, 1) for the missing XYZW components.
      */
-    int comp_len = has_radius ? 4 : 3;
-    pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, comp_len, GPU_FETCH_FLOAT);
+    pos = GPU_vertformat_attr_add(&format_no_radius, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
+    pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
   }
 
-  cache->pos = GPU_vertbuf_create_with_format(&format);
+  cache->pos = GPU_vertbuf_create_with_format(has_radius ? &format : &format_no_radius);
   GPU_vertbuf_data_alloc(cache->pos, pointcloud->totpoint);
 
   if (has_radius) {
diff --git a/source/blender/draw/intern/draw_common.h b/source/blender/draw/intern/draw_common.h
index 81c0e97a1a8..09f901c344f 100644
--- a/source/blender/draw/intern/draw_common.h
+++ b/source/blender/draw/intern/draw_common.h
@@ -27,8 +27,10 @@ struct DRWPass;
 struct DRWShadingGroup;
 struct GPUMaterial;
 struct ModifierData;
+struct FluidModifierData;
 struct Object;
 struct ParticleSystem;
+struct RegionView3D;
 struct ViewLayer;
 
 #define UBO_FIRST_COLOR colorWire
@@ -159,14 +161,14 @@ void DRW_globals_update(void);
 void DRW_globals_free(void);
 
 struct DRWView *DRW_view_create_with_zoffset(const struct DRWView *parent_view,
-                                             const RegionView3D *rv3d,
+                                             const struct RegionView3D *rv3d,
                                              float offset);
 
 int DRW_object_wire_theme_get(struct Object *ob, struct ViewLayer *view_layer, float **r_color);
 float *DRW_color_background_blend_get(int theme_id);
 
-bool DRW_object_is_flat(Object *ob, int *r_axis);
-bool DRW_object_axis_orthogonal_to_view(Object *ob, int axis);
+bool DRW_object_is_flat(struct Object *ob, int *r_axis);
+bool DRW_object_axis_orthogonal_to_view(struct Object *ob, int axis);
 
 /* draw_hair.c */
 
@@ -188,6 +190,16 @@ void DRW_hair_init(void);
 void DRW_hair_update(void);
 void DRW_hair_free(void);
 
+/* draw_fluid.c */
+
+/* Fluid simulation.  */
+void DRW_smoke_ensure(struct FluidModifierData *fmd, int highres);
+void DRW_smoke_ensure_coba_field(struct FluidModifierData *fmd);
+void DRW_smoke_ensure_velocity(struct FluidModifierData *fmd);
+
+void DRW_smoke_free(struct FluidModifierData *fmd);
+void DRW_smoke_free_velocity(struct FluidModifierData *fmd);
+
 /* draw_common.c */
 struct DRW_Global {
   /** If needed, contains all global/Theme colors
diff --git a/source/blender/draw/intern/draw_fluid.c b/source/blender/draw/intern/draw_fluid.c
new file mode 100644
index 00000000000..33311dc698f
--- /dev/null
+++ b/source/blender/draw/intern/draw_fluid.c
@@ -0,0 +1,419 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2005 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup gpu
+ *
+ * GPU fluid drawing functions.
+ */
+
+#include <string.h>
+
+#include "BLI_math.h"
+#include "BLI_utildefines.h"
+
+#include "DNA_fluid_types.h"
+#include "DNA_modifier_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BKE_colorband.h"
+
+#include "GPU_texture.h"
+
+#include "draw_common.h" /* Own include. */
+
+#ifdef WITH_FLUID
+#  include "manta_fluid_API.h"
+#endif
+
+/* -------------------------------------------------------------------- */
+/** \name Private API
+ * \{ */
+
+#ifdef WITH_FLUID
+
+enum {
+  TFUNC_FLAME_SPECTRUM = 0,
+  TFUNC_COLOR_RAMP = 1,
+};
+
+#  define TFUNC_WIDTH 256
+
+static void create_flame_spectrum_texture(float *data)
+{
+#  define FIRE_THRESH 7
+#  define MAX_FIRE_ALPHA 0.06f
+#  define FULL_ON_FIRE 100
+
+  float *spec_pixels = (float *)MEM_mallocN(TFUNC_WIDTH * 4 * 16 * 16 * sizeof(float),
+                                            "spec_pixels");
+
+  blackbody_temperature_to_rgb_table(data, TFUNC_WIDTH, 1500, 3000);
+
+  for (int i = 0; i < 16; i++) {
+    for (int j = 0; j < 16; j++) {
+      for (int k = 0; k < TFUNC_WIDTH; k++) {
+        int index = (j * TFUNC_WIDTH * 16 + i * TFUNC_WIDTH + k) * 4;
+        if (k >= FIRE_THRESH) {
+          spec_pixels[index] = (data[k * 4]);
+          spec_pixels[index + 1] = (data[k * 4 + 1]);
+          spec_pixels[index + 2] = (data[k * 4 + 2]);
+          spec_pixels[index + 3] = MAX_FIRE_ALPHA *
+                                   ((k > FULL_ON_FIRE) ?
+                                        1.0f :
+                                        (k - FIRE_THRESH) / ((float)FULL_ON_FIRE - FIRE_THRESH));
+        }
+        else {
+          zero_v4(&spec_pixels[index]);
+        }
+      }
+    }
+  }
+
+  memcpy(data, spec_pixels, sizeof(float) * 4 * TFUNC_WIDTH);
+
+  MEM_freeN(spec_pixels);
+
+#  undef FIRE_THRESH
+#  undef MAX_FIRE_ALPHA
+#  undef FULL_ON_FIRE
+}
+
+static void create_color_ramp(const struct ColorBand *coba, float *data)
+{
+  for (int i = 0; i < TFUNC_WIDTH; i++) {
+    BKE_colorband_evaluate(coba, (float)i / TFUNC_WIDTH, &data[i * 4]);
+    straight_to_premul_v4(&data[i * 4]);
+  }
+}
+
+static GPUTexture *create_transfer_function(int type, const struct ColorBand *coba)
+{
+  float *data = (float *)MEM_mallocN(sizeof(float) * 4 * TFUNC_WIDTH, __func__);
+
+  switch (type) {
+    case TFUNC_FLAME_SPECTRUM:
+      create_flame_spectrum_texture(data);
+      break;
+    case TFUNC_COLOR_RAMP:
+      create_color_ramp(coba, data);
+      break;
+  }
+
+  GPUTexture *tex = GPU_texture_create_1d(TFUNC_WIDTH, GPU_SRGB8_A8, data, NULL);
+
+  MEM_freeN(data);
+
+  return tex;
+}
+
+static void swizzle_texture_channel_single(GPUTexture *tex)
+{
+  /* Swizzle texture channels so that we get useful RGBA values when sampling
+   * a texture with fewer channels, e.g. when using density as color. */
+  GPU_texture_bind(tex, 0);
+  GPU_texture_swizzle_set(tex, "rrr1");
+  GPU_texture_unbind(tex);
+}
+
+static GPUTexture *create_field_texture(FluidDomainSettings *fds)
+{
+  float *field = NULL;
+
+  switch (fds->coba_field) {
+    case FLUID_DOMAIN_FIELD_DENSITY:
+      field = manta_smoke_get_density(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_HEAT:
+      field = manta_smoke_get_heat(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_FUEL:
+      field = manta_smoke_get_fuel(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_REACT:
+      field = manta_smoke_get_react(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_FLAME:
+      field = manta_smoke_get_flame(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_VELOCITY_X:
+      field = manta_get_velocity_x(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_VELOCITY_Y:
+      field = manta_get_velocity_y(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_VELOCITY_Z:
+      field = manta_get_velocity_z(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_COLOR_R:
+      field = manta_smoke_get_color_r(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_COLOR_G:
+      field = manta_smoke_get_color_g(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_COLOR_B:
+      field = manta_smoke_get_color_b(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_FORCE_X:
+      field = manta_get_force_x(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_FORCE_Y:
+      field = manta_get_force_y(fds->fluid);
+      break;
+    case FLUID_DOMAIN_FIELD_FORCE_Z:
+      field = manta_get_force_z(fds->fluid);
+      break;
+    default:
+      return NULL;
+  }
+
+  GPUTexture *tex = GPU_texture_create_nD(
+      UNPACK3(fds->res), 3, field, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
+
+  swizzle_texture_channel_single(tex);
+  return tex;
+}
+
+static GPUTexture *create_density_texture(FluidDomainSettings *fds, int highres)
+{
+  int *dim = (highres) ? fds->res_noise : fds->res;
+
+  float *data;
+  if (highres) {
+    data = manta_noise_get_density(fds->fluid);
+  }
+  else {
+    data = manta_smoke_get_density(fds->fluid);
+  }
+
+  GPUTexture *tex = GPU_texture_create_nD(
+      UNPACK3(dim), 3, data, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
+
+  swizzle_texture_channel_single(tex);
+
+  return tex;
+}
+
+static GPUTexture *create_color_texture(FluidDomainSettings *fds, int highres)
+{
+  const bool has_color = (highres) ? manta_noise_has_colors(fds->fluid) :
+                                     manta_smoke_has_colors(fds->fluid);
+
+  if (!has_color) {
+    return NULL;
+  }
+
+  int cell_count = (highres) ? manta_noise_get_cells(fds->fluid) : fds->total_cells;
+  int *dim = (highres) ? fds->res_noise : fds->res;
+  float *data = (float *)MEM_callocN(sizeof(float) * cell_count * 4, "smokeColorTexture");
+
+  if (data == NULL) {
+    return NULL;
+  }
+
+  if (highres) {
+    manta_noise_get_rgba(fds->fluid, data, 0);
+  }
+  else {
+    manta_smoke_get_rgba(fds->fluid, data, 0);
+  }
+
+  GPUTexture *tex = GPU_texture_create_nD(
+      dim[0], dim[1], dim[2], 3, data, GPU_RGBA8, GPU_DATA_FLOAT, 0, true, NULL);
+
+  MEM_freeN(data);
+
+  return tex;
+}
+
+static GPUTexture *create_flame_texture(FluidDomainSettings *fds, int highres)
+{
+  float *source = NULL;
+  const bool has_fuel = (highres) ? manta_noise_has_fuel(fds->fluid) :
+                                    manta_smoke_has_fuel(fds->fluid);
+  int *dim = (highres) ? fds->res_noise : fds->res;
+
+  if (!has_fuel) {
+    return NULL;
+  }
+
+  if (highres) {
+    source = manta_noise_get_flame(fds->fluid);
+  }
+  else {
+    source = manta_smoke_get_flame(fds->fluid);
+  }
+
+  GPUTexture *tex = GPU_texture_create_nD(
+      dim[0], dim[1], dim[2], 3, source, GPU_R8, GPU_DATA_FLOAT, 0, true, NULL);
+
+  swizzle_texture_channel_single(tex);
+
+  return tex;
+}
+
+#endif /* WITH_FLUID */
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Public API
+ * \{ */
+
+void DRW_smoke_free(FluidModifierData *fmd)
+{
+  if (fmd->type & MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
+    if (fmd->domain->tex_density) {
+      GPU_texture_free(fmd->domain->tex_density);
+      fmd->domain->tex_density = NULL;
+    }
+
+    if (fmd->domain->tex_color) {
+      GPU_texture_free(fmd->domain->tex_color);
+      fmd->domain->tex_color = NULL;
+    }
+
+    if (fmd->domain->tex_shadow) {
+      GPU_texture_free(fmd->domain->tex_shadow);
+      fmd->domain->tex_shadow = NULL;
+    }
+
+    if (fmd->domain->tex_flame) {
+      GPU_texture_free(fmd->domain->tex_flame);
+      fmd->domain->tex_flame = NULL;
+    }
+
+    if (fmd->domain->tex_flame_coba) {
+      GPU_texture_free(fmd->domain->tex_flame_coba);
+      fmd->domain->tex_flame_coba = NULL;
+    }
+
+    if (fmd->domain->tex_coba) {
+      GPU_texture_free(fmd->domain->tex_coba);
+      fmd->domain->tex_coba = NULL;
+    }
+
+    if (fmd->domain->tex_field) {
+      GPU_texture_free(fmd->domain->tex_field);
+      fmd->domain->tex_field = NULL;
+    }
+  }
+}
+
+void DRW_smoke_ensure_coba_field(FluidModifierData *fmd)
+{
+#ifndef WITH_FLUID
+  UNUSED_VARS(fmd);
+#else
+  if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *fds = fmd->domain;
+
+    if (!fds->tex_field) {
+      fds->tex_field = create_field_texture(fds);
+    }
+    if (!fds->tex_coba) {
+      fds->tex_coba = create_transfer_function(TFUNC_COLOR_RAMP, fds->coba);
+    }
+  }
+#endif
+}
+
+void DRW_smoke_ensure(FluidModifierData *fmd, int highres)
+{
+#ifndef WITH_FLUID
+  UNUSED_VARS(fmd, highres);
+#else
+  if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *fds = fmd->domain;
+
+    if (!fds->tex_density) {
+      fds->tex_density = create_density_texture(fds, highres);
+    }
+    if (!fds->tex_color) {
+      fds->tex_color = create_color_texture(fds, highres);
+    }
+    if (!fds->tex_flame) {
+      fds->tex_flame = create_flame_texture(fds, highres);
+    }
+    if (!fds->tex_flame_coba && fds->tex_flame) {
+      fds->tex_flame_coba = create_transfer_function(TFUNC_FLAME_SPECTRUM, NULL);
+    }
+    if (!fds->tex_shadow) {
+      fds->tex_shadow = GPU_texture_create_nD(UNPACK3(fds->res),
+                                              3,
+                                              manta_smoke_get_shadow(fds->fluid),
+                                              GPU_R8,
+                                              GPU_DATA_FLOAT,
+                                              0,
+                                              true,
+                                              NULL);
+    }
+  }
+#endif /* WITH_FLUID */
+}
+
+void DRW_smoke_ensure_velocity(FluidModifierData *fmd)
+{
+#ifndef WITH_FLUID
+  UNUSED_VARS(fmd);
+#else
+  if (fmd->type & MOD_FLUID_TYPE_DOMAIN) {
+    FluidDomainSettings *fds = fmd->domain;
+
+    const float *vel_x = manta_get_velocity_x(fds->fluid);
+    const float *vel_y = manta_get_velocity_y(fds->fluid);
+    const float *vel_z = manta_get_velocity_z(fds->fluid);
+
+    if (ELEM(NULL, vel_x, vel_y, vel_z)) {
+      return;
+    }
+
+    if (!fds->tex_velocity_x) {
+      fds->tex_velocity_x = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_x, NULL);
+      fds->tex_velocity_y = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_y, NULL);
+      fds->tex_velocity_z = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_z, NULL);
+    }
+  }
+#endif /* WITH_FLUID */
+}
+
+/* TODO Unify with the other DRW_smoke_free. */
+void DRW_smoke_free_velocity(FluidModifierData *fmd)
+{
+  if (fmd->type & MOD_FLUID_TYPE_DOMAIN && fmd->domain) {
+    if (fmd->domain->tex_velocity_x) {
+      GPU_texture_free(fmd->domain->tex_velocity_x);
+    }
+
+    if (fmd->domain->tex_velocity_y) {
+      GPU_texture_free(fmd->domain->tex_velocity_y);
+    }
+
+    if (fmd->domain->tex_velocity_z) {
+      GPU_texture_free(fmd->domain->tex_velocity_z);
+    }
+
+    fmd->domain->tex_velocity_x = NULL;
+    fmd->domain->tex_velocity_y = NULL;
+    fmd->domain->tex_velocity_z = NULL;
+  }
+}
+
+/** \} */
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index 70c117d55b4..ede589f5bba 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -2716,7 +2716,7 @@ void DRW_engines_free(void)
 void DRW_render_context_enable(Render *render)
 {
   if (G.background && DST.gl_context == NULL) {
-    WM_init_opengl(G_MAIN);
+    WM_init_opengl();
   }
 
   if (GPU_use_main_context_workaround()) {
@@ -2847,7 +2847,7 @@ void DRW_opengl_context_disable_ex(bool restore)
 void DRW_opengl_context_enable(void)
 {
   if (G.background && DST.gl_context == NULL) {
-    WM_init_opengl(G_MAIN);
+    WM_init_opengl();
   }
   DRW_opengl_context_enable_ex(true);
 }
diff --git a/source/blender/draw/intern/draw_manager_data.c b/source/blender/draw/intern/draw_manager_data.c
index 9d8050504ab..3184d6155d2 100644
--- a/source/blender/draw/intern/draw_manager_data.c
+++ b/source/blender/draw/intern/draw_manager_data.c
@@ -1292,13 +1292,10 @@ static DRWShadingGroup *drw_shgroup_material_create_ex(GPUPass *gpupass, DRWPass
 }
 
 static void drw_shgroup_material_texture(DRWShadingGroup *grp,
-                                         GPUMaterialTexture *tex,
+                                         GPUTexture *gputex,
                                          const char *name,
-                                         eGPUSamplerState state,
-                                         int textarget)
+                                         eGPUSamplerState state)
 {
-  GPUTexture *gputex = GPU_texture_from_blender(tex->ima, tex->iuser, NULL, textarget);
-
   DRW_shgroup_uniform_texture_ex(grp, name, gputex, state);
 
   GPUTexture **gputex_ref = BLI_memblock_alloc(DST.vmempool->images);
@@ -1314,15 +1311,16 @@ void DRW_shgroup_add_material_resources(DRWShadingGroup *grp, struct GPUMaterial
   LISTBASE_FOREACH (GPUMaterialTexture *, tex, &textures) {
     if (tex->ima) {
       /* Image */
+      GPUTexture *gputex;
       if (tex->tiled_mapping_name[0]) {
-        drw_shgroup_material_texture(
-            grp, tex, tex->sampler_name, tex->sampler_state, GL_TEXTURE_2D_ARRAY);
-        drw_shgroup_material_texture(
-            grp, tex, tex->tiled_mapping_name, tex->sampler_state, GL_TEXTURE_1D_ARRAY);
+        gputex = BKE_image_get_gpu_tiles(tex->ima, tex->iuser, NULL);
+        drw_shgroup_material_texture(grp, gputex, tex->sampler_name, tex->sampler_state);
+        gputex = BKE_image_get_gpu_tilemap(tex->ima, tex->iuser, NULL);
+        drw_shgroup_material_texture(grp, gputex, tex->tiled_mapping_name, tex->sampler_state);
       }
       else {
-        drw_shgroup_material_texture(
-            grp, tex, tex->sampler_name, tex->sampler_state, GL_TEXTURE_2D);
+        gputex = BKE_image_get_gpu_texture(tex->ima, tex->iuser, NULL);
+        drw_shgroup_material_texture(grp, gputex, tex->sampler_name, tex->sampler_state);
       }
     }
     else if (tex->colorband) {
diff --git a/source/blender/draw/intern/draw_manager_exec.c b/source/blender/draw/intern/draw_manager_exec.c
index b6f51ada5a1..91cbc03e5a4 100644
--- a/source/blender/draw/intern/draw_manager_exec.c
+++ b/source/blender/draw/intern/draw_manager_exec.c
@@ -446,6 +446,7 @@ void DRW_state_reset(void)
   DRW_state_reset_ex(DRW_STATE_DEFAULT);
 
   GPU_texture_unbind_all();
+  GPU_uniformbuffer_unbind_all();
 
   /* Should stay constant during the whole rendering. */
   GPU_point_size(5);
@@ -669,8 +670,7 @@ BLI_INLINE void draw_geometry_bind(DRWShadingGroup *shgroup, GPUBatch *geom)
 
   DST.batch = geom;
 
-  GPU_batch_program_set_no_use(
-      geom, GPU_shader_get_program(shgroup->shader), GPU_shader_get_interface(shgroup->shader));
+  GPU_batch_set_shader_no_bind(geom, shgroup->shader);
 
   geom->program_in_use = true; /* XXX hacking #GPUBatch */
 
@@ -773,10 +773,11 @@ static bool ubo_bindings_validate(DRWShadingGroup *shgroup)
       DRWPass *parent_pass = DRW_memblock_elem_from_handle(DST.vmempool->passes,
                                                            &shgroup->pass_handle);
 
-      printf("Pass : %s, Shader : %s, Block : %s\n",
+      printf("Pass : %s, Shader : %s, Block : %s, Binding %d\n",
              parent_pass->name,
              shgroup->shader->name,
-             blockname);
+             blockname,
+             binding);
     }
   }
 #  endif
@@ -1106,6 +1107,7 @@ static void draw_shgroup(DRWShadingGroup *shgroup, DRWState pass_state)
       /* Unbinding can be costly. Skip in normal condition. */
       if (G.debug & G_DEBUG_GPU) {
         GPU_texture_unbind_all();
+        GPU_uniformbuffer_unbind_all();
       }
     }
     GPU_shader_bind(shgroup->shader);
diff --git a/source/blender/draw/intern/draw_manager_shader.c b/source/blender/draw/intern/draw_manager_shader.c
index 34069438e47..1c260721efb 100644
--- a/source/blender/draw/intern/draw_manager_shader.c
+++ b/source/blender/draw/intern/draw_manager_shader.c
@@ -447,7 +447,8 @@ GPUMaterial *DRW_shader_create_from_world(struct Scene *scene,
                                           const char *geom,
                                           const char *frag_lib,
                                           const char *defines,
-                                          bool deferred)
+                                          bool deferred,
+                                          GPUMaterialEvalCallbackFn callback)
 {
   GPUMaterial *mat = NULL;
   if (DRW_state_is_image_render() || !deferred) {
@@ -467,7 +468,8 @@ GPUMaterial *DRW_shader_create_from_world(struct Scene *scene,
                                      geom,
                                      frag_lib,
                                      defines,
-                                     wo->id.name);
+                                     wo->id.name,
+                                     callback);
   }
 
   if (GPU_material_status(mat) == GPU_MAT_QUEUED) {
@@ -487,7 +489,8 @@ GPUMaterial *DRW_shader_create_from_material(struct Scene *scene,
                                              const char *geom,
                                              const char *frag_lib,
                                              const char *defines,
-                                             bool deferred)
+                                             bool deferred,
+                                             GPUMaterialEvalCallbackFn callback)
 {
   GPUMaterial *mat = NULL;
   if (DRW_state_is_image_render() || !deferred) {
@@ -507,7 +510,8 @@ GPUMaterial *DRW_shader_create_from_material(struct Scene *scene,
                                      geom,
                                      frag_lib,
                                      defines,
-                                     ma->id.name);
+                                     ma->id.name,
+                                     callback);
   }
 
   if (GPU_material_status(mat) == GPU_MAT_QUEUED) {
diff --git a/source/blender/draw/intern/draw_select_buffer.c b/source/blender/draw/intern/draw_select_buffer.c
index 84c8d0f861f..ee5561e1e38 100644
--- a/source/blender/draw/intern/draw_select_buffer.c
+++ b/source/blender/draw/intern/draw_select_buffer.c
@@ -395,7 +395,7 @@ uint DRW_select_buffer_find_nearest_to_point(struct Depsgraph *depsgraph,
           int center_x = width / 2;
           int center_y = height / 2;
 
-          /* Manhatten distance in keeping with other screen-based selection. */
+          /* Manhattan distance in keeping with other screen-based selection. */
           *dist = (uint)(abs(hit_x - center_x) + abs(hit_y - center_y));
 
           /* Indices start at 1 here. */
diff --git a/source/blender/draw/intern/draw_view.c b/source/blender/draw/intern/draw_view.c
index 3c470f802ec..b42700b2c7e 100644
--- a/source/blender/draw/intern/draw_view.c
+++ b/source/blender/draw/intern/draw_view.c
@@ -184,8 +184,7 @@ void DRW_draw_cursor(void)
 
       GPUBatch *cursor_batch = DRW_cache_cursor_get(is_aligned);
       GPUShader *shader = GPU_shader_get_builtin_shader(GPU_SHADER_2D_FLAT_COLOR);
-      GPU_batch_program_set(
-          cursor_batch, GPU_shader_get_program(shader), GPU_shader_get_interface(shader));
+      GPU_batch_set_shader(cursor_batch, shader);
 
       GPU_batch_draw(cursor_batch);
 
diff --git a/source/blender/draw/intern/shaders/common_hair_lib.glsl b/source/blender/draw/intern/shaders/common_hair_lib.glsl
index ffff631e34b..8684d82f228 100644
--- a/source/blender/draw/intern/shaders/common_hair_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_hair_lib.glsl
@@ -95,7 +95,7 @@ void hair_get_interp_attrs(
  * For final drawing, the vertex index and the number of vertex per segment
  */
 
-#ifndef HAIR_PHASE_SUBDIV
+#if !defined(HAIR_PHASE_SUBDIV) && defined(GPU_VERTEX_SHADER)
 int hair_get_strand_id(void)
 {
   return gl_VertexID / (hairStrandsRes * hairThicknessRes);
@@ -206,4 +206,24 @@ vec3 hair_get_strand_pos(void)
   return texelFetch(hairPointBuffer, id).point_position;
 }
 
+vec2 hair_get_barycentric(void)
+{
+  /* To match cycles without breaking into individual segment we encode if we need to invert
+   * the first component into the second component. We invert if the barycentricTexCo.y
+   * is NOT 0.0 or 1.0. */
+  int id = hair_get_base_id();
+  return vec2(float((id % 2) == 1), float(((id % 4) % 3) > 0));
+}
+
 #endif
+
+/* To be fed the result of hair_get_barycentric from vertex shader. */
+vec2 hair_resolve_barycentric(vec2 vert_barycentric)
+{
+  if (fract(vert_barycentric.y) != 0.0) {
+    return vec2(vert_barycentric.x, 0.0);
+  }
+  else {
+    return vec2(1.0 - vert_barycentric.x, 0.0);
+  }
+}
diff --git a/source/blender/draw/intern/shaders/common_math_geom_lib.glsl b/source/blender/draw/intern/shaders/common_math_geom_lib.glsl
index e337376d7c4..643d7e7d942 100644
--- a/source/blender/draw/intern/shaders/common_math_geom_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_math_geom_lib.glsl
@@ -116,4 +116,4 @@ vec3 normal_decode(vec2 enc, vec3 view)
   return n;
 }
 
-/** \} */
\ No newline at end of file
+/** \} */
diff --git a/source/blender/draw/intern/shaders/common_pointcloud_lib.glsl b/source/blender/draw/intern/shaders/common_pointcloud_lib.glsl
index 36b67f2bd60..625e8bb1ff8 100644
--- a/source/blender/draw/intern/shaders/common_pointcloud_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_pointcloud_lib.glsl
@@ -36,4 +36,4 @@ vec3 pointcloud_get_pos(void)
   vec3 outpos, outnor;
   pointcloud_get_pos_and_nor(outpos, outnor);
   return outpos;
-}
\ No newline at end of file
+}
diff --git a/source/blender/draw/intern/shaders/common_view_lib.glsl b/source/blender/draw/intern/shaders/common_view_lib.glsl
index 095bc64a19e..a55d2cd8c1a 100644
--- a/source/blender/draw/intern/shaders/common_view_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_view_lib.glsl
@@ -22,6 +22,16 @@ layout(std140) uniform viewBlock
   vec4 CameraTexCoFactors;
 };
 
+#define ViewNear (ViewVecs[0].w)
+#define ViewFar (ViewVecs[1].w)
+
+#define cameraForward ViewMatrixInverse[2].xyz
+#define cameraPos ViewMatrixInverse[3].xyz
+#define cameraVec \
+  ((ProjectionMatrix[3][3] == 0.0) ? normalize(cameraPos - worldPosition) : cameraForward)
+#define viewCameraVec \
+  ((ProjectionMatrix[3][3] == 0.0) ? normalize(-viewPosition) : vec3(0.0, 0.0, 1.0))
+
 #ifdef world_clip_planes_calc_clip_distance
 #  undef world_clip_planes_calc_clip_distance
 #  define world_clip_planes_calc_clip_distance(p) \
@@ -104,10 +114,13 @@ uniform int resourceId;
 
 /* Use this to declare and pass the value if
  * the fragment shader uses the resource_id. */
-#  define RESOURCE_ID_VARYING flat out int resourceIDFrag;
-#  define RESOURCE_ID_VARYING_GEOM flat out int resourceIDGeom;
-#  define PASS_RESOURCE_ID resourceIDFrag = resource_id;
-#  define PASS_RESOURCE_ID_GEOM resourceIDGeom = resource_id;
+#  ifdef USE_GEOMETRY_SHADER
+#    define RESOURCE_ID_VARYING flat out int resourceIDGeom;
+#    define PASS_RESOURCE_ID resourceIDGeom = resource_id;
+#  else
+#    define RESOURCE_ID_VARYING flat out int resourceIDFrag;
+#    define PASS_RESOURCE_ID resourceIDFrag = resource_id;
+#  endif
 #endif
 
 /* If used in a fragment / geometry shader, we pass
@@ -118,7 +131,7 @@ uniform int resourceId;
     flat in int resourceIDGeom[];
 
 #  define resource_id resourceIDGeom
-#  define PASS_RESOURCE_ID(i) resourceIDFrag = resource_id[i];
+#  define PASS_RESOURCE_ID resourceIDFrag = resource_id[0];
 #endif
 
 #ifdef GPU_FRAGMENT_SHADER
@@ -171,9 +184,12 @@ uniform mat4 ModelMatrixInverse;
  * Note: This is only valid because we are only using the mat3 of the ViewMatrixInverse.
  * ViewMatrix * transpose(ModelMatrixInverse)
  **/
-#define normal_object_to_view(n) (mat3(ViewMatrix) * (transpose(mat3(ModelMatrixInverse)) * n))
-#define normal_object_to_world(n) (transpose(mat3(ModelMatrixInverse)) * n)
-#define normal_world_to_object(n) (transpose(mat3(ModelMatrix)) * n)
+#define NormalMatrix transpose(mat3(ModelMatrixInverse))
+#define NormalMatrixInverse transpose(mat3(ModelMatrix))
+
+#define normal_object_to_view(n) (mat3(ViewMatrix) * (NormalMatrix * n))
+#define normal_object_to_world(n) (NormalMatrix * n)
+#define normal_world_to_object(n) (NormalMatrixInverse * n)
 #define normal_world_to_view(n) (mat3(ViewMatrix) * n)
 #define normal_view_to_world(n) (mat3(ViewMatrixInverse) * n)
 
@@ -199,3 +215,78 @@ uniform mat4 ModelMatrixInverse;
 #define DRW_BASE_FROM_DUPLI (1 << 2)
 #define DRW_BASE_FROM_SET (1 << 3)
 #define DRW_BASE_ACTIVE (1 << 4)
+
+/* ---- Opengl Depth conversion ---- */
+
+float linear_depth(bool is_persp, float z, float zf, float zn)
+{
+  if (is_persp) {
+    return (zn * zf) / (z * (zn - zf) + zf);
+  }
+  else {
+    return (z * 2.0 - 1.0) * zf;
+  }
+}
+
+float buffer_depth(bool is_persp, float z, float zf, float zn)
+{
+  if (is_persp) {
+    return (zf * (zn - z)) / (z * (zn - zf));
+  }
+  else {
+    return (z / (zf * 2.0)) + 0.5;
+  }
+}
+
+float get_view_z_from_depth(float depth)
+{
+  if (ProjectionMatrix[3][3] == 0.0) {
+    float d = 2.0 * depth - 1.0;
+    return -ProjectionMatrix[3][2] / (d + ProjectionMatrix[2][2]);
+  }
+  else {
+    return ViewVecs[0].z + depth * ViewVecs[1].z;
+  }
+}
+
+float get_depth_from_view_z(float z)
+{
+  if (ProjectionMatrix[3][3] == 0.0) {
+    float d = (-ProjectionMatrix[3][2] / z) - ProjectionMatrix[2][2];
+    return d * 0.5 + 0.5;
+  }
+  else {
+    return (z - ViewVecs[0].z) / ViewVecs[1].z;
+  }
+}
+
+vec2 get_uvs_from_view(vec3 view)
+{
+  vec4 ndc = ProjectionMatrix * vec4(view, 1.0);
+  return (ndc.xy / ndc.w) * 0.5 + 0.5;
+}
+
+vec3 get_view_space_from_depth(vec2 uvcoords, float depth)
+{
+  if (ProjectionMatrix[3][3] == 0.0) {
+    return vec3(ViewVecs[0].xy + uvcoords * ViewVecs[1].xy, 1.0) * get_view_z_from_depth(depth);
+  }
+  else {
+    return ViewVecs[0].xyz + vec3(uvcoords, depth) * ViewVecs[1].xyz;
+  }
+}
+
+vec3 get_world_space_from_depth(vec2 uvcoords, float depth)
+{
+  return (ViewMatrixInverse * vec4(get_view_space_from_depth(uvcoords, depth), 1.0)).xyz;
+}
+
+vec3 get_view_vector_from_screen_uv(vec2 uv)
+{
+  if (ProjectionMatrix[3][3] == 0.0) {
+    return normalize(vec3(ViewVecs[0].xy + uv * ViewVecs[1].xy, 1.0));
+  }
+  else {
+    return vec3(0.0, 0.0, 1.0);
+  }
+}