render_data.inv_cam_transform = render_data.cam_transform.affine_inverse();

render_data.cam_projection = p_camera_data->main_projection;

render_data.cam_orthogonal = p_camera_data->is_orthogonal;

render_data.camera_visible_layers = p_camera_data->visible_layers;

render_data.main_cam_transform = p_camera_data->main_transform;

scene_state.enable_gl_blend(false);

scene_state.set_gl_cull_mode(GLES3::SceneShaderData::CULL_BACK);

Projection projection = render_data.cam_projection;

if (is_reflection_probe) {

Projection correction;

correction.columns[1][1] = -1.0;

projection = correction * render_data.cam_projection;

}

}

if (rt && (scene_state.used_screen_texture || scene_state.used_depth_texture)) {

Transform3D inv_cam_transform;

Projection cam_projection;

bool cam_orthogonal = false;

uint32_t camera_visible_layers = 0xFFFFFFFF;

// For billboards to cast correct shadows.

sky.setup_sky(p_render_data->environment, rb, *p_render_data->lights, p_render_data->camera_attributes, 1, &projection, &eye_offset, p_render_data->scene_data->cam_transform, projection, screen_size, Vector2(0.0f, 0.0f), this);

} else {

}

sky_energy_multiplier *= bg_energy_multiplier;

sky.setup_sky(p_render_data->environment, p_render_data->render_buffers, *p_render_data->lights, p_render_data->camera_attributes, 1, &projection, &eye_offset, p_render_data->scene_data->cam_transform, projection, screen_size, Vector2(0.0f, 0.0f), this);

} else {

}

sky_energy_multiplier *= bg_energy_multiplier;

scene_data.cam_transform = p_camera_data->main_transform;

scene_data.cam_projection = p_camera_data->main_projection;

scene_data.cam_orthogonal = p_camera_data->is_orthogonal;

scene_data.camera_visible_layers = p_camera_data->visible_layers;

scene_data.taa_jitter = p_camera_data->taa_jitter;

scene_data.taa_frame_count = p_camera_data->taa_frame_count;

float taa_frame_count = 0.0f;

uint32_t camera_visible_layers;

bool cam_orthogonal = false;

bool flip_y = false;

// For billboards to cast correct shadows.

Projection projection;

bool vaspect = camera->vaspect;

bool is_orthogonal = false;

switch (camera->type) {

case Camera::ORTHOGONAL: {

camera->znear,

camera->zfar,

camera->vaspect);

} break;

}

} else {

// Setup our camera for our XR interface.

// We can support multiple views here each with their own camera

}

if (view_count == 1) {

} else if (view_count == 2) {

} else {

// this won't be called (see fail check above) but keeping this comment to indicate we may support more then 2 views in the future...

}

RENDER_TIMESTAMP("Render Empty 3D Scene");

RendererSceneRender::CameraData camera_data;

scene_render->render_scene(p_render_buffers, &camera_data, &camera_data, PagedArray<RenderGeometryInstance *>(), PagedArray<RID>(), PagedArray<RID>(), PagedArray<RID>(), PagedArray<RID>(), PagedArray<RID>(), PagedArray<RID>(), environment, RID(), compositor, p_shadow_atlas, RID(), scenario->reflection_atlas, RID(), 0, 0, nullptr, 0, nullptr, 0, nullptr);

#endif

RENDER_TIMESTAMP("Render ReflectionProbe, Step " + itos(p_step));

RendererSceneRender::CameraData camera_data;

Ref<RenderSceneBuffers> render_buffers = RSG::light_storage->reflection_probe_atlas_get_render_buffers(scenario->reflection_atlas);

_render_scene(&camera_data, render_buffers, environment, RID(), RID(), RSG::light_storage->reflection_probe_get_cull_mask(p_instance->base), p_instance->scenario->self, RID(), shadow_atlas, reflection_probe->instance, p_step, mesh_lod_threshold, use_shadows);

/////////////////////////////////////////////////////////////////////////////

// CameraData

view_count = 1;

is_orthogonal = p_is_orthogonal;

vaspect = p_vaspect;

main_transform = p_transform;

taa_frame_count = p_taa_frame_count;

}

ERR_FAIL_COND_MSG(p_view_count != 2, "Incorrect view count for stereoscopic view");

visible_layers = 0xFFFFFFFF;

view_count = p_view_count;

is_orthogonal = p_is_orthogonal;

vaspect = p_vaspect;

Vector<Plane> planes[2];

// flags

uint32_t view_count;

bool is_orthogonal;

uint32_t visible_layers;

bool vaspect;

Vector2 taa_jitter;

float taa_frame_count = 0.0f;

};

virtual void render_scene(const Ref<RenderSceneBuffers> &p_render_buffers, const CameraData *p_camera_data, const CameraData *p_prev_camera_data, const PagedArray<RenderGeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, const PagedArray<RID> &p_fog_volumes, RID p_environment, RID p_camera_attributes, RID p_compositor, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data = nullptr, RenderingMethod::RenderInfo *r_render_info = nullptr) = 0;