Fix T65212: Cycles SSS failing on 32 bit

intern/cycles/kernel/closure/bsdf_ashikhmin_velvet.h

@@ -42,6 +42,8 @@ typedef ccl_addr_space struct VelvetBsdf {
   float invsigma2;
 } VelvetBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(VelvetBsdf), "VelvetBsdf is too large!");
+
 ccl_device int bsdf_ashikhmin_velvet_setup(VelvetBsdf *bsdf)
 {
   float sigma = fmaxf(bsdf->sigma, 0.01f);

intern/cycles/kernel/closure/bsdf_diffuse.h

@@ -39,6 +39,8 @@ typedef ccl_addr_space struct DiffuseBsdf {
   SHADER_CLOSURE_BASE;
 } DiffuseBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(DiffuseBsdf), "DiffuseBsdf is too large!");
+
 /* DIFFUSE */
 
 ccl_device int bsdf_diffuse_setup(DiffuseBsdf *bsdf)

intern/cycles/kernel/closure/bsdf_diffuse_ramp.h

@@ -43,6 +43,8 @@ typedef ccl_addr_space struct DiffuseRampBsdf {
   float3 *colors;
 } DiffuseRampBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(DiffuseRampBsdf), "DiffuseRampBsdf is too large!");
+
 ccl_device float3 bsdf_diffuse_ramp_get_color(const float3 colors[8], float pos)
 {
   int MAXCOLORS = 8;

intern/cycles/kernel/closure/bsdf_hair.h

@@ -44,6 +44,8 @@ typedef ccl_addr_space struct HairBsdf {
   float offset;
 } HairBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(HairBsdf), "HairBsdf is too large!");
+
 ccl_device int bsdf_hair_reflection_setup(HairBsdf *bsdf)
 {
   bsdf->type = CLOSURE_BSDF_HAIR_REFLECTION_ID;

intern/cycles/kernel/closure/bsdf_microfacet.h

@@ -48,6 +48,8 @@ typedef ccl_addr_space struct MicrofacetBsdf {
   float3 T;
 } MicrofacetBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(MicrofacetBsdf), "MicrofacetBsdf is too large!");
+
 /* Beckmann and GGX microfacet importance sampling. */
 
 ccl_device_inline void microfacet_beckmann_sample_slopes(KernelGlobals *kg,

intern/cycles/kernel/closure/bsdf_oren_nayar.h

@@ -27,6 +27,8 @@ typedef ccl_addr_space struct OrenNayarBsdf {
   float b;
 } OrenNayarBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(OrenNayarBsdf), "OrenNayarBsdf is too large!");
+
 ccl_device float3 bsdf_oren_nayar_get_intensity(const ShaderClosure *sc,
                                                 float3 n,
                                                 float3 v,

intern/cycles/kernel/closure/bsdf_phong_ramp.h

@@ -44,6 +44,8 @@ typedef ccl_addr_space struct PhongRampBsdf {
   float3 *colors;
 } PhongRampBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(PhongRampBsdf), "PhongRampBsdf is too large!");
+
 ccl_device float3 bsdf_phong_ramp_get_color(const float3 colors[8], float pos)
 {
   int MAXCOLORS = 8;

intern/cycles/kernel/closure/bsdf_principled_diffuse.h

@@ -30,6 +30,9 @@ typedef ccl_addr_space struct PrincipledDiffuseBsdf {
   float roughness;
 } PrincipledDiffuseBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(PrincipledDiffuseBsdf),
+              "PrincipledDiffuseBsdf is too large!");
+
 ccl_device float3 calculate_principled_diffuse_brdf(
     const PrincipledDiffuseBsdf *bsdf, float3 N, float3 V, float3 L, float3 H, float *pdf)
 {

intern/cycles/kernel/closure/bsdf_principled_sheen.h

@@ -28,6 +28,9 @@ typedef ccl_addr_space struct PrincipledSheenBsdf {
   SHADER_CLOSURE_BASE;
 } PrincipledSheenBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(PrincipledSheenBsdf),
+              "PrincipledSheenBsdf is too large!");
+
 ccl_device float3 calculate_principled_sheen_brdf(
     const PrincipledSheenBsdf *bsdf, float3 N, float3 V, float3 L, float3 H, float *pdf)
 {

intern/cycles/kernel/closure/bsdf_toon.h

@@ -42,6 +42,8 @@ typedef ccl_addr_space struct ToonBsdf {
   float smooth;
 } ToonBsdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(ToonBsdf), "ToonBsdf is too large!");
+
 /* DIFFUSE TOON */
 
 ccl_device int bsdf_diffuse_toon_setup(ToonBsdf *bsdf)

intern/cycles/kernel/closure/bssrdf.h

@@ -30,6 +30,8 @@ typedef ccl_addr_space struct Bssrdf {
   float channels;
 } Bssrdf;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(Bssrdf), "Bssrdf is too large!");
+
 /* Planar Truncated Gaussian
  *
  * Note how this is different from the typical gaussian, this one integrates

intern/cycles/kernel/closure/volume.h

@@ -40,6 +40,9 @@ typedef ccl_addr_space struct HenyeyGreensteinVolume {
   float g;
 } HenyeyGreensteinVolume;
 
+static_assert(sizeof(ShaderClosure) >= sizeof(HenyeyGreensteinVolume),
+              "HenyeyGreensteinVolume is too large!");
+
 /* Given cosine between rays, return probability density that a photon bounces
  * to that direction. The g parameter controls how different it is from the
  * uniform sphere. g=0 uniform diffuse-like, g=1 close to sharp single ray. */

intern/cycles/kernel/kernel_types.h

@@ -804,8 +804,9 @@ typedef struct AttributeDescriptor {
  * ShaderClosure has a fixed size, and any extra space must be allocated
  * with closure_alloc_extra().
  *
- * We pad the struct to 80 bytes and ensure it is aligned to 16 bytes, which
+ * We pad the struct to align to 16 bytes. All shader closures are assumed
- * we assume to be the maximum required alignment for any struct. */
+ * to fit in this struct size. CPU sizes are a bit larger because float3 is
+ * padded to be 16 bytes, while it's only 12 bytes on the GPU. */
 
 #define SHADER_CLOSURE_BASE \
   float3 weight; \
@@ -817,7 +818,10 @@ typedef ccl_addr_space struct ccl_align(16) ShaderClosure
 {
   SHADER_CLOSURE_BASE;
 
-  float data[10]; /* pad to 80 bytes */
+#ifdef __KERNEL_CPU__
+  float pad[2];
+#endif
+  float data[10];
 }
 ShaderClosure;