blender-archive/source/blender/draw/engines/eevee/shaders/closure_eval_lib.glsl

#pragma BLENDER_REQUIRE(common_utiltex_lib.glsl)
// #pragma (gpu_shader_codegen_lib.glsl)
#pragma BLENDER_REQUIRE(lights_lib.glsl)
#pragma BLENDER_REQUIRE(lightprobe_lib.glsl)

#ifndef GPU_FRAGMENT_SHADER
#  define gl_FragCoord vec4(0.0)
#  define gl_FrontFacing true
#endif

/**
 * Extensive use of Macros to be able to change the maximum amount of evaluated closure easily.
 * NOTE: GLSL does not support variadic macros.
 *
 * Example
 * // Declare the cl_eval function
 * CLOSURE_EVAL_FUNCTION_DECLARE_3(name, Diffuse, Glossy, Refraction);
 * // Declare the inputs & outputs
 * CLOSURE_VARS_DECLARE(Diffuse, Glossy, Refraction);
 * // Specify inputs
 * in_Diffuse_0.N = N;
 * ...
 * // Call the cl_eval function
 * CLOSURE_EVAL_FUNCTION_3(name, Diffuse, Glossy, Refraction);
 * // Get the cl_out
 * closure.radiance = out_Diffuse_0.radiance + out_Glossy_1.radiance + out_Refraction_2.radiance;
 */

#define CLOSURE_VARS_DECLARE(t0, t1, t2, t3) \
  ClosureInputCommon in_common = CLOSURE_INPUT_COMMON_DEFAULT; \
  ClosureInput##t0 in_##t0##_0 = CLOSURE_INPUT_##t0##_DEFAULT; \
  ClosureInput##t1 in_##t1##_1 = CLOSURE_INPUT_##t1##_DEFAULT; \
  ClosureInput##t2 in_##t2##_2 = CLOSURE_INPUT_##t2##_DEFAULT; \
  ClosureInput##t3 in_##t3##_3 = CLOSURE_INPUT_##t3##_DEFAULT; \
  ClosureOutput##t0 out_##t0##_0; \
  ClosureOutput##t1 out_##t1##_1; \
  ClosureOutput##t2 out_##t2##_2; \
  ClosureOutput##t3 out_##t3##_3;

#define CLOSURE_EVAL_DECLARE(t0, t1, t2, t3) \
  ClosureEvalCommon cl_common = closure_Common_eval_init(in_common); \
  ClosureEval##t0 eval_##t0##_0 = closure_##t0##_eval_init(in_##t0##_0, cl_common, out_##t0##_0); \
  ClosureEval##t1 eval_##t1##_1 = closure_##t1##_eval_init(in_##t1##_1, cl_common, out_##t1##_1); \
  ClosureEval##t2 eval_##t2##_2 = closure_##t2##_eval_init(in_##t2##_2, cl_common, out_##t2##_2); \
  ClosureEval##t3 eval_##t3##_3 = closure_##t3##_eval_init(in_##t3##_3, cl_common, out_##t3##_3);

#define CLOSURE_META_SUBROUTINE(subroutine, t0, t1, t2, t3) \
  closure_##t0##_##subroutine(in_##t0##_0, eval_##t0##_0, cl_common, out_##t0##_0); \
  closure_##t1##_##subroutine(in_##t1##_1, eval_##t1##_1, cl_common, out_##t1##_1); \
  closure_##t2##_##subroutine(in_##t2##_2, eval_##t2##_2, cl_common, out_##t2##_2); \
  closure_##t3##_##subroutine(in_##t3##_3, eval_##t3##_3, cl_common, out_##t3##_3);

#define CLOSURE_META_SUBROUTINE_DATA(subroutine, sub_data, t0, t1, t2, t3) \
  closure_##t0##_##subroutine(in_##t0##_0, eval_##t0##_0, cl_common, sub_data, out_##t0##_0); \
  closure_##t1##_##subroutine(in_##t1##_1, eval_##t1##_1, cl_common, sub_data, out_##t1##_1); \
  closure_##t2##_##subroutine(in_##t2##_2, eval_##t2##_2, cl_common, sub_data, out_##t2##_2); \
  closure_##t3##_##subroutine(in_##t3##_3, eval_##t3##_3, cl_common, sub_data, out_##t3##_3);

#ifndef DEPTH_SHADER
/* Inputs are inout so that callers can get the final inputs used for evaluation. */
#  define CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, t1, t2, t3) \
    void closure_##name##_eval(ClosureInputCommon in_common, \
                               inout ClosureInput##t0 in_##t0##_0, \
                               inout ClosureInput##t1 in_##t1##_1, \
                               inout ClosureInput##t2 in_##t2##_2, \
                               inout ClosureInput##t3 in_##t3##_3, \
                               out ClosureOutput##t0 out_##t0##_0, \
                               out ClosureOutput##t1 out_##t1##_1, \
                               out ClosureOutput##t2 out_##t2##_2, \
                               out ClosureOutput##t3 out_##t3##_3) \
    { \
      CLOSURE_EVAL_DECLARE(t0, t1, t2, t3); \
\
      /* Starts at 1 because 0 is world cubemap. */ \
      for (int i = 1; cl_common.specular_accum > 0.0 && i < prbNumRenderCube && i < MAX_PROBE; \
           i++) { \
        ClosureCubemapData cube = closure_cubemap_eval_init(i, cl_common); \
        if (cube.attenuation > 1e-8) { \
          CLOSURE_META_SUBROUTINE_DATA(cubemap_eval, cube, t0, t1, t2, t3); \
        } \
      } \
\
      /* Starts at 1 because 0 is world irradiance. */ \
      for (int i = 1; cl_common.diffuse_accum > 0.0 && i < prbNumRenderGrid && i < MAX_GRID; \
           i++) { \
        ClosureGridData grid = closure_grid_eval_init(i, cl_common); \
        if (grid.attenuation > 1e-8) { \
          CLOSURE_META_SUBROUTINE_DATA(grid_eval, grid, t0, t1, t2, t3); \
        } \
      } \
\
      CLOSURE_META_SUBROUTINE(indirect_end, t0, t1, t2, t3); \
\
      ClosurePlanarData planar = closure_planar_eval_init(cl_common); \
      if (planar.attenuation > 1e-8) { \
        CLOSURE_META_SUBROUTINE_DATA(planar_eval, planar, t0, t1, t2, t3); \
      } \
\
      for (int i = 0; i < laNumLight && i < MAX_LIGHT; i++) { \
        ClosureLightData light = closure_light_eval_init(cl_common, i); \
        if (light.vis > 1e-8) { \
          CLOSURE_META_SUBROUTINE_DATA(light_eval, light, t0, t1, t2, t3); \
        } \
      } \
\
      CLOSURE_META_SUBROUTINE(eval_end, t0, t1, t2, t3); \
    }

#else
/* Inputs are inout so that callers can get the final inputs used for evaluation. */
#  define CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, t1, t2, t3) \
    void closure_##name##_eval(ClosureInputCommon in_common, \
                               inout ClosureInput##t0 in_##t0##_0, \
                               inout ClosureInput##t1 in_##t1##_1, \
                               inout ClosureInput##t2 in_##t2##_2, \
                               inout ClosureInput##t3 in_##t3##_3, \
                               out ClosureOutput##t0 out_##t0##_0, \
                               out ClosureOutput##t1 out_##t1##_1, \
                               out ClosureOutput##t2 out_##t2##_2, \
                               out ClosureOutput##t3 out_##t3##_3) \
    { \
      CLOSURE_EVAL_DECLARE(t0, t1, t2, t3); \
    }
#endif

#define CLOSURE_EVAL_FUNCTION(name, t0, t1, t2, t3) \
  closure_##name##_eval(in_common, \
                        in_##t0##_0, \
                        in_##t1##_1, \
                        in_##t2##_2, \
                        in_##t3##_3, \
                        out_##t0##_0, \
                        out_##t1##_1, \
                        out_##t2##_2, \
                        out_##t3##_3)

#define CLOSURE_EVAL_FUNCTION_DECLARE_1(name, t0) \
  CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, Dummy, Dummy, Dummy)
#define CLOSURE_EVAL_FUNCTION_DECLARE_2(name, t0, t1) \
  CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, t1, Dummy, Dummy)
#define CLOSURE_EVAL_FUNCTION_DECLARE_3(name, t0, t1, t2) \
  CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, t1, t2, Dummy)
#define CLOSURE_EVAL_FUNCTION_DECLARE_4(name, t0, t1, t2, t3) \
  CLOSURE_EVAL_FUNCTION_DECLARE(name, t0, t1, t2, t3)

#define CLOSURE_VARS_DECLARE_1(t0) CLOSURE_VARS_DECLARE(t0, Dummy, Dummy, Dummy)
#define CLOSURE_VARS_DECLARE_2(t0, t1) CLOSURE_VARS_DECLARE(t0, t1, Dummy, Dummy)
#define CLOSURE_VARS_DECLARE_3(t0, t1, t2) CLOSURE_VARS_DECLARE(t0, t1, t2, Dummy)
#define CLOSURE_VARS_DECLARE_4(t0, t1, t2, t3) CLOSURE_VARS_DECLARE(t0, t1, t2, t3)

#define CLOSURE_EVAL_FUNCTION_1(name, t0) CLOSURE_EVAL_FUNCTION(name, t0, Dummy, Dummy, Dummy)
#define CLOSURE_EVAL_FUNCTION_2(name, t0, t1) CLOSURE_EVAL_FUNCTION(name, t0, t1, Dummy, Dummy)
#define CLOSURE_EVAL_FUNCTION_3(name, t0, t1, t2) CLOSURE_EVAL_FUNCTION(name, t0, t1, t2, Dummy)
#define CLOSURE_EVAL_FUNCTION_4(name, t0, t1, t2, t3) CLOSURE_EVAL_FUNCTION(name, t0, t1, t2, t3)

/* -------------------------------------------------------------------- */
/** \name Dummy Closure
 *
 * Dummy closure type that will be optimized out by the compiler.
 * \{ */

#define ClosureInputDummy ClosureOutput
#define ClosureOutputDummy ClosureOutput
#define ClosureEvalDummy ClosureOutput
#ifdef GPU_METAL
/* C++ struct initialization. */
#  define CLOSURE_EVAL_DUMMY \
    { \
      vec3(0) \
    }
#else
#  define CLOSURE_EVAL_DUMMY ClosureOutput(vec3(0))
#endif
#define CLOSURE_INPUT_Dummy_DEFAULT CLOSURE_EVAL_DUMMY
#define closure_Dummy_eval_init(cl_in, cl_common, cl_out) CLOSURE_EVAL_DUMMY
#define closure_Dummy_planar_eval(cl_in, cl_eval, cl_common, data, cl_out)
#define closure_Dummy_cubemap_eval(cl_in, cl_eval, cl_common, data, cl_out)
#define closure_Dummy_grid_eval(cl_in, cl_eval, cl_common, data, cl_out)
#define closure_Dummy_indirect_end(cl_in, cl_eval, cl_common, cl_out)
#define closure_Dummy_light_eval(cl_in, cl_eval, cl_common, data, cl_out)
#define closure_Dummy_eval_end(cl_in, cl_eval, cl_common, cl_out)

/** \} */

/* -------------------------------------------------------------------- */
/** \name Common cl_eval data
 *
 * Eval data not dependent on input parameters. All might not be used but unused ones
 * will be optimized out.
 * \{ */

struct ClosureInputCommon {
  /** Custom occlusion value set by the user. */
  float occlusion;
};
#ifdef GPU_METAL
/* C++ struct initialization. */
#  define CLOSURE_INPUT_COMMON_DEFAULT \
    { \
      1.0 \
    }
#else
#  define CLOSURE_INPUT_COMMON_DEFAULT ClosureInputCommon(1.0)
#endif

struct ClosureEvalCommon {
  /** Result of SSAO. */
  OcclusionData occlusion_data;
  /** View vector. */
  vec3 V;
  /** Surface position. */
  vec3 P;
  /** Normal vector, always facing camera. */
  vec3 N;
  /** Normal vector, always facing camera. (viewspace) */
  vec3 vN;
  /** Surface position. (viewspace) */
  vec3 vP;
  /** Geometric normal, always facing camera. */
  vec3 Ng;
  /** Geometric normal, always facing camera. (viewspace) */
  vec3 vNg;
  /** Random numbers. 3 random sequences. zw is a random point on a circle. */
  vec4 rand;
  /** Specular probe accumulator. Shared between planar and cubemap probe. */
  float specular_accum;
  /** Diffuse probe accumulator. */
  float diffuse_accum;
};

/* Common cl_out struct used by most closures. */
struct ClosureOutput {
  vec3 radiance;
};

/* Workaround for screenspace shadows in SSR pass. */
float FragDepth;

ClosureEvalCommon closure_Common_eval_init(ClosureInputCommon cl_in)
{
  ClosureEvalCommon cl_eval;
  cl_eval.rand = texelfetch_noise_tex(gl_FragCoord.xy);
  cl_eval.V = cameraVec(worldPosition);
  cl_eval.P = worldPosition;
  cl_eval.N = safe_normalize(gl_FrontFacing ? worldNormal : -worldNormal);
  cl_eval.vN = safe_normalize(gl_FrontFacing ? viewNormal : -viewNormal);
  cl_eval.vP = viewPosition;
#ifdef GPU_FRAGMENT_SHADER
  cl_eval.Ng = safe_normalize(cross(dFdx(cl_eval.P), dFdy(cl_eval.P)));
#else
  cl_eval.Ng = cl_eval.N;
#endif
  cl_eval.vNg = transform_direction(ViewMatrix, cl_eval.Ng);

  cl_eval.occlusion_data = occlusion_load(cl_eval.vP, cl_in.occlusion);

  cl_eval.specular_accum = 1.0;
  cl_eval.diffuse_accum = 1.0;
  return cl_eval;
}

/** \} */

/* -------------------------------------------------------------------- */
/** \name Loop data
 *
 * Loop data is conveniently packed into struct to make it future proof.
 * \{ */

struct ClosureLightData {
  LightData data; /** Light Data. */
  vec4 L;         /** Non-Normalized Light Vector (surface to light) with length in W component. */
  float vis;      /** Light visibility. */
  float contact_shadow; /** Result of contact shadow tracing. */
};

ClosureLightData closure_light_eval_init(ClosureEvalCommon cl_common, int light_id)
{
  ClosureLightData light;
  light.data = lights_data[light_id];

  light.L.xyz = light.data.l_position - cl_common.P;
  light.L.w = length(light.L.xyz);

  light.vis = light_visibility(light.data, cl_common.P, light.L);
  light.contact_shadow = light_contact_shadows(
      light.data, cl_common.P, cl_common.vP, cl_common.vNg, cl_common.rand.x, light.vis);

  return light;
}

struct ClosureCubemapData {
  int id;            /** Probe id. */
  float attenuation; /** Attenuation. */
};

ClosureCubemapData closure_cubemap_eval_init(int cube_id, inout ClosureEvalCommon cl_common)
{
  ClosureCubemapData cube;
  cube.id = cube_id;
  cube.attenuation = probe_attenuation_cube(cube_id, cl_common.P);
  cube.attenuation = min(cube.attenuation, cl_common.specular_accum);
  cl_common.specular_accum -= cube.attenuation;
  return cube;
}

struct ClosurePlanarData {
  int id;            /** Probe id. */
  PlanarData data;   /** planars_data[id]. */
  float attenuation; /** Attenuation. */
};

ClosurePlanarData closure_planar_eval_init(inout ClosureEvalCommon cl_common)
{
  ClosurePlanarData planar;
  planar.attenuation = 0.0;

  /* TODO(fclem): Find planar with the maximum weight. */
  for (int i = 0; i < prbNumPlanar && i < MAX_PLANAR; i++) {
    float attenuation = probe_attenuation_planar(planars_data[i], cl_common.P);
    if (attenuation > planar.attenuation) {
      planar.id = i;
      planar.attenuation = attenuation;
      planar.data = planars_data[i];
    }
  }
  return planar;
}

struct ClosureGridData {
  int id;            /** Grid id. */
  GridData data;     /** grids_data[id] */
  float attenuation; /** Attenuation. */
  vec3 local_pos;    /** Local position inside the grid. */
};

ClosureGridData closure_grid_eval_init(int id, inout ClosureEvalCommon cl_common)
{
  ClosureGridData grid;
  grid.id = id;
  grid.data = grids_data[id];
  grid.attenuation = probe_attenuation_grid(grid.data, cl_common.P, grid.local_pos);
  grid.attenuation = min(grid.attenuation, cl_common.diffuse_accum);
  cl_common.diffuse_accum -= grid.attenuation;
  return grid;
}

/** \} */

#ifndef GPU_FRAGMENT_SHADER
#  undef gl_FragCoord
#  undef gl_FrontFacing
#endif