actions.render_mode_defines["specular_occlusion_conservative"] = "#define SPECULAR_OCCLUSION_CONSERVATIVE\n";

actions.render_mode_defines["specular_occlusion"] = "#define SPECULAR_OCCLUSION\n";

if (p_using_opaque_gi) {

// Inherit Dynamic GI reflections

flags |= INSTANCE_DATA_FLAG_USE_GI_BUFFERS;

}

if (inst->voxel_gi_instances[0].is_valid()) {

// Inherit VoxelGI reflections

flags |= INSTANCE_DATA_FLAG_USE_VOXEL_GI;

}

if (p_using_opaque_gi) {

// Inherit Dynamic GI reflections

flags |= INSTANCE_DATA_FLAG_USE_GI_BUFFERS;

}

if (inst->voxel_gi_instances[0].is_valid()) {

// Inherit VoxelGI reflections

flags |= INSTANCE_DATA_FLAG_USE_VOXEL_GI;

}

actions.render_mode_defines["specular_occlusion_conservative"] = "#define SPECULAR_OCCLUSION_CONSERVATIVE\n";

actions.render_mode_defines["specular_occlusion"] = "#define SPECULAR_OCCLUSION\n";

if (sc_use_forward_gi && bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_VOXEL_GI)) { // inherit VoxelGI reflections

uint index1 = instances.data[instance_index].gi_offset & 0xFFFF;

// Make vertex orientation the world one, but still align to camera.

vec3 cam_pos = mat3(scene_data.inv_view_matrix) * vertex;

vec3 cam_normal = mat3(scene_data.inv_view_matrix) * normal;

vec3 ref_vec = mat3(scene_data.inv_view_matrix) * normalize(reflect(-view, normal));

//find arbitrary tangent and bitangent, then build a matrix

vec3 v0 = abs(cam_normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);

vec3 tangent = normalize(cross(v0, cam_normal));

vec3 bitangent = normalize(cross(tangent, cam_normal));

mat3 normal_mat = mat3(tangent, bitangent, cam_normal);

vec4 spec_accum = vec4(0.0);

voxel_gi_compute_irradiance_only(index1, cam_pos, cam_normal, ref_vec, normal_mat, roughness * roughness, specular_light, spec_accum);

uint index2 = instances.data[instance_index].gi_offset >> 16;

if (index2 != 0xFFFF) {

voxel_gi_compute_irradiance_only(index2, cam_pos, cam_normal, ref_vec, normal_mat, roughness * roughness, specular_light, spec_accum);

}

if (spec_accum.a > 0.0) {

spec_accum.rgb /= spec_accum.a;

}

specular_light = spec_accum.rgb;

}

float specular_occlusion;

specular_occlusion = (c.r * 0.3 + c.g * 0.59 + c.b * 0.11) * 2.0; // brightness from lightmap color

specular_occlusion = (c.r * 0.3 + c.g * 0.59 + c.b * 0.11) * 2.0; // brightness from lightmap color

if (!sc_use_forward_gi && bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_GI_BUFFERS)) { // Inherit gi reflections on lightmapped objects

vec2 coord;

if (implementation_data.gi_upscale_for_msaa) {

vec2 base_coord = screen_uv;

vec2 closest_coord = base_coord;

#ifdef USE_MULTIVIEW

float closest_ang = dot(normal, textureLod(sampler2DArray(normal_roughness_buffer, SAMPLER_LINEAR_CLAMP), vec3(base_coord, ViewIndex), 0.0).xyz * 2.0 - 1.0);

#else // USE_MULTIVIEW

float closest_ang = dot(normal, textureLod(sampler2D(normal_roughness_buffer, SAMPLER_LINEAR_CLAMP), base_coord, 0.0).xyz * 2.0 - 1.0);

#endif // USE_MULTIVIEW

for (int i = 0; i < 4; i++) {

const vec2 neighbors[4] = vec2[](vec2(-1, 0), vec2(1, 0), vec2(0, -1), vec2(0, 1));

vec2 neighbour_coord = base_coord + neighbors[i] * scene_data.screen_pixel_size;

#ifdef USE_MULTIVIEW

float neighbour_ang = dot(normal, textureLod(sampler2DArray(normal_roughness_buffer, SAMPLER_LINEAR_CLAMP), vec3(neighbour_coord, ViewIndex), 0.0).xyz * 2.0 - 1.0);

#else // USE_MULTIVIEW

float neighbour_ang = dot(normal, textureLod(sampler2D(normal_roughness_buffer, SAMPLER_LINEAR_CLAMP), neighbour_coord, 0.0).xyz * 2.0 - 1.0);

#endif // USE_MULTIVIEW

if (neighbour_ang > closest_ang) {

closest_ang = neighbour_ang;

closest_coord = neighbour_coord;

}

}

coord = closest_coord;

} else {

coord = screen_uv;

}

#ifdef USE_MULTIVIEW

vec4 buffer_reflection = textureLod(sampler2DArray(reflection_buffer, SAMPLER_LINEAR_CLAMP), vec3(coord, ViewIndex), 0.0);

#else // USE_MULTIVIEW

vec4 buffer_reflection = textureLod(sampler2D(reflection_buffer, SAMPLER_LINEAR_CLAMP), coord, 0.0);

#endif // USE_MULTIVIEW

// try to keep SDFGI reflections while making sure dark areas from the lightmap should be dark

specular_light = mix(specular_light, buffer_reflection.rgb * min(specular_occlusion * specular_occlusion * 8.0, 1.0), buffer_reflection.a);

}

void voxel_gi_compute_irradiance_only(uint index, vec3 position, vec3 normal, vec3 ref_vec, mat3 normal_xform, float roughness, vec3 environment, inout vec4 out_spec) {

position = (voxel_gi_instances.data[index].xform * vec4(position, 1.0)).xyz;

ref_vec = normalize((voxel_gi_instances.data[index].xform * vec4(ref_vec, 0.0)).xyz);

normal = normalize((voxel_gi_instances.data[index].xform * vec4(normal, 0.0)).xyz);

position += normal * voxel_gi_instances.data[index].normal_bias;

//this causes corrupted pixels, i have no idea why..

if (any(bvec2(any(lessThan(position, vec3(0.0))), any(greaterThan(position, voxel_gi_instances.data[index].bounds))))) {

return;

}

vec3 blendv = abs(position / voxel_gi_instances.data[index].bounds * 2.0 - 1.0);

float blend = clamp(1.0 - max(blendv.x, max(blendv.y, blendv.z)), 0.0, 1.0);

//float blend=1.0;

float max_distance = length(voxel_gi_instances.data[index].bounds);

vec3 cell_size = 1.0 / voxel_gi_instances.data[index].bounds;

//irradiance

vec4 irr_light = voxel_cone_trace(voxel_gi_textures[index], cell_size, position, ref_vec, tan(roughness * 0.5 * M_PI * 0.99), max_distance, voxel_gi_instances.data[index].bias);

if (voxel_gi_instances.data[index].blend_ambient) {

irr_light.rgb = mix(environment, irr_light.rgb, min(1.0, irr_light.a / 0.95));

}

irr_light.rgb *= voxel_gi_instances.data[index].dynamic_range * voxel_gi_instances.data[index].exposure_normalization;

//irr_light=vec3(0.0);

out_spec += vec4(irr_light.rgb * blend, blend);

}