CoCalc -- renderer_scene

GitHub Repository: godotengine/godot
Path: blob/master/servers/rendering/renderer_scene_render.cpp
¹⁰²⁷⁷ views
1
/**************************************************************************/
2
/*  renderer_scene_render.cpp                                             */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#include "renderer_scene_render.h"
32

33
/////////////////////////////////////////////////////////////////////////////
34
// CameraData
35

36
void RendererSceneRender::CameraData::set_camera(const Transform3D p_transform, const Projection p_projection, bool p_is_orthogonal, bool p_is_frustum, bool p_vaspect, const Vector2 &p_taa_jitter, float p_taa_frame_count, const uint32_t p_visible_layers) {
37
	view_count = 1;
38
	is_orthogonal = p_is_orthogonal;
39
	is_frustum = p_is_frustum;
40
	vaspect = p_vaspect;
41

42
	main_transform = p_transform;
43
	main_projection = p_projection;
44

45
	visible_layers = p_visible_layers;
46
	view_offset[0] = Transform3D();
47
	view_projection[0] = p_projection;
48
	taa_jitter = p_taa_jitter;
49
	taa_frame_count = p_taa_frame_count;
50
}
51

52
void RendererSceneRender::CameraData::set_multiview_camera(uint32_t p_view_count, const Transform3D *p_transforms, const Projection *p_projections, bool p_is_orthogonal, bool p_is_frustum, bool p_vaspect) {
53
	ERR_FAIL_COND_MSG(p_view_count != 2, "Incorrect view count for stereoscopic view");
54

55
	visible_layers = 0xFFFFFFFF;
56
	view_count = p_view_count;
57
	is_orthogonal = p_is_orthogonal;
58
	is_frustum = p_is_frustum;
59
	vaspect = p_vaspect;
60
	Vector<Plane> planes[2];
61

62
	/////////////////////////////////////////////////////////////////////////////
63
	// Figure out our center transform
64

65
	// 1. obtain our planes
66
	for (uint32_t v = 0; v < view_count; v++) {
67
		planes[v] = p_projections[v].get_projection_planes(p_transforms[v]);
68
	}
69

70
	// 2. average and normalize plane normals to obtain z vector, cross them to obtain y vector, and from there the x vector for combined camera basis.
71
	Vector3 n0 = planes[0][Projection::PLANE_LEFT].normal;
72
	Vector3 n1 = planes[1][Projection::PLANE_RIGHT].normal;
73
	Vector3 z = (n0 + n1).normalized();
74
	Vector3 y = n0.cross(n1).normalized();
75
	Vector3 x = y.cross(z).normalized();
76
	y = z.cross(x).normalized();
77
	main_transform.basis.set_columns(x, y, z);
78

79
	// 3. create a horizon plane with one of the eyes and the up vector as normal.
80
	Plane horizon(y, p_transforms[0].origin);
81

82
	// 4. Intersect horizon, left and right to obtain the combined camera origin.
83
	ERR_FAIL_COND_MSG(
84
			!horizon.intersect_3(planes[0][Projection::PLANE_LEFT], planes[1][Projection::PLANE_RIGHT], &main_transform.origin), "Can't determine camera origin");
85

86
	// handy to have the inverse of the transform we just build
87
	Transform3D main_transform_inv = main_transform.inverse();
88

89
	// 5. figure out far plane, this could use some improvement, we may have our far plane too close like this, not sure if this matters
90
	Vector3 far_center = (planes[0][Projection::PLANE_FAR].get_center() + planes[1][Projection::PLANE_FAR].get_center()) * 0.5;
91
	Plane far_plane = Plane(-z, far_center);
92

93
	/////////////////////////////////////////////////////////////////////////////
94
	// Figure out our top/bottom planes
95

96
	// 6. Intersect far and left planes with top planes from both eyes, save the point with highest y as top_left.
97
	Vector3 top_left, other;
98
	ERR_FAIL_COND_MSG(
99
			!far_plane.intersect_3(planes[0][Projection::PLANE_LEFT], planes[0][Projection::PLANE_TOP], &top_left), "Can't determine left camera far/left/top vector");
100
	ERR_FAIL_COND_MSG(
101
			!far_plane.intersect_3(planes[1][Projection::PLANE_LEFT], planes[1][Projection::PLANE_TOP], &other), "Can't determine right camera far/left/top vector");
102
	if (y.dot(top_left) < y.dot(other)) {
103
		top_left = other;
104
	}
105

106
	// 7. Intersect far and left planes with bottom planes from both eyes, save the point with lowest y as bottom_left.
107
	Vector3 bottom_left;
108
	ERR_FAIL_COND_MSG(
109
			!far_plane.intersect_3(planes[0][Projection::PLANE_LEFT], planes[0][Projection::PLANE_BOTTOM], &bottom_left), "Can't determine left camera far/left/bottom vector");
110
	ERR_FAIL_COND_MSG(
111
			!far_plane.intersect_3(planes[1][Projection::PLANE_LEFT], planes[1][Projection::PLANE_BOTTOM], &other), "Can't determine right camera far/left/bottom vector");
112
	if (y.dot(other) < y.dot(bottom_left)) {
113
		bottom_left = other;
114
	}
115

116
	// 8. Intersect far and right planes with top planes from both eyes, save the point with highest y as top_right.
117
	Vector3 top_right;
118
	ERR_FAIL_COND_MSG(
119
			!far_plane.intersect_3(planes[0][Projection::PLANE_RIGHT], planes[0][Projection::PLANE_TOP], &top_right), "Can't determine left camera far/right/top vector");
120
	ERR_FAIL_COND_MSG(
121
			!far_plane.intersect_3(planes[1][Projection::PLANE_RIGHT], planes[1][Projection::PLANE_TOP], &other), "Can't determine right camera far/right/top vector");
122
	if (y.dot(top_right) < y.dot(other)) {
123
		top_right = other;
124
	}
125

126
	//  9. Intersect far and right planes with bottom planes from both eyes, save the point with lowest y as bottom_right.
127
	Vector3 bottom_right;
128
	ERR_FAIL_COND_MSG(
129
			!far_plane.intersect_3(planes[0][Projection::PLANE_RIGHT], planes[0][Projection::PLANE_BOTTOM], &bottom_right), "Can't determine left camera far/right/bottom vector");
130
	ERR_FAIL_COND_MSG(
131
			!far_plane.intersect_3(planes[1][Projection::PLANE_RIGHT], planes[1][Projection::PLANE_BOTTOM], &other), "Can't determine right camera far/right/bottom vector");
132
	if (y.dot(other) < y.dot(bottom_right)) {
133
		bottom_right = other;
134
	}
135

136
	// 10. Create top plane with these points: camera origin, top_left, top_right
137
	Plane top(main_transform.origin, top_left, top_right);
138

139
	// 11. Create bottom plane with these points: camera origin, bottom_left, bottom_right
140
	Plane bottom(main_transform.origin, bottom_left, bottom_right);
141

142
	/////////////////////////////////////////////////////////////////////////////
143
	// Figure out our near plane points
144

145
	// 12. Create a near plane using -camera z and the eye further along in that axis.
146
	Plane near_plane;
147
	Vector3 neg_z = -z;
148
	if (neg_z.dot(p_transforms[1].origin) < neg_z.dot(p_transforms[0].origin)) {
149
		near_plane = Plane(neg_z, p_transforms[0].origin);
150
	} else {
151
		near_plane = Plane(neg_z, p_transforms[1].origin);
152
	}
153

154
	// 13. Intersect near plane with bottm/left planes, to obtain min_vec then top/right to obtain max_vec
155
	Vector3 min_vec;
156
	ERR_FAIL_COND_MSG(
157
			!near_plane.intersect_3(bottom, planes[0][Projection::PLANE_LEFT], &min_vec), "Can't determine left camera near/left/bottom vector");
158
	ERR_FAIL_COND_MSG(
159
			!near_plane.intersect_3(bottom, planes[1][Projection::PLANE_LEFT], &other), "Can't determine right camera near/left/bottom vector");
160
	if (x.dot(other) < x.dot(min_vec)) {
161
		min_vec = other;
162
	}
163

164
	Vector3 max_vec;
165
	ERR_FAIL_COND_MSG(
166
			!near_plane.intersect_3(top, planes[0][Projection::PLANE_RIGHT], &max_vec), "Can't determine left camera near/right/top vector");
167
	ERR_FAIL_COND_MSG(
168
			!near_plane.intersect_3(top, planes[1][Projection::PLANE_RIGHT], &other), "Can't determine right camera near/right/top vector");
169
	if (x.dot(max_vec) < x.dot(other)) {
170
		max_vec = other;
171
	}
172

173
	// 14. transform these points by the inverse camera to obtain local_min_vec and local_max_vec
174
	Vector3 local_min_vec = main_transform_inv.xform(min_vec);
175
	Vector3 local_max_vec = main_transform_inv.xform(max_vec);
176

177
	// 15. get x and y from these to obtain left, top, right bottom for the frustum. Get the distance from near plane to camera origin to obtain near, and the distance from the far plane to the camera origin to obtain far.
178
	float z_near = -near_plane.distance_to(main_transform.origin);
179
	float z_far = -far_plane.distance_to(main_transform.origin);
180

181
	// 16. Use this to build the combined camera matrix.
182
	main_projection.set_frustum(local_min_vec.x, local_max_vec.x, local_min_vec.y, local_max_vec.y, z_near, z_far);
183

184
	/////////////////////////////////////////////////////////////////////////////
185
	// 3. Copy our view data
186
	for (uint32_t v = 0; v < view_count; v++) {
187
		view_offset[v] = main_transform_inv * p_transforms[v];
188
		view_projection[v] = p_projections[v] * Projection(view_offset[v].inverse());
189
	}
190
}
191

192
/* Compositor effect API */
193

194
RID RendererSceneRender::compositor_effect_allocate() {
195
	return compositor_storage.compositor_effect_allocate();
196
}
197

198
void RendererSceneRender::compositor_effect_initialize(RID p_rid) {
199
	compositor_storage.compositor_effect_initialize(p_rid);
200
}
201

202
void RendererSceneRender::compositor_effect_free(RID p_rid) {
203
	compositor_storage.compositor_effect_free(p_rid);
204
}
205

206
bool RendererSceneRender::is_compositor_effect(RID p_effect) const {
207
	return compositor_storage.is_compositor_effect(p_effect);
208
}
209

210
void RendererSceneRender::compositor_effect_set_enabled(RID p_effect, bool p_enabled) {
211
	compositor_storage.compositor_effect_set_enabled(p_effect, p_enabled);
212
}
213

214
void RendererSceneRender::compositor_effect_set_callback(RID p_effect, RS::CompositorEffectCallbackType p_callback_type, const Callable &p_callback) {
215
	compositor_storage.compositor_effect_set_callback(p_effect, p_callback_type, p_callback);
216
}
217

218
void RendererSceneRender::compositor_effect_set_flag(RID p_effect, RS::CompositorEffectFlags p_flag, bool p_set) {
219
	compositor_storage.compositor_effect_set_flag(p_effect, p_flag, p_set);
220
}
221

222
/* Compositor API */
223

224
RID RendererSceneRender::compositor_allocate() {
225
	return compositor_storage.compositor_allocate();
226
}
227

228
void RendererSceneRender::compositor_initialize(RID p_rid) {
229
	compositor_storage.compositor_initialize(p_rid);
230
}
231

232
void RendererSceneRender::compositor_free(RID p_rid) {
233
	compositor_storage.compositor_free(p_rid);
234
}
235

236
bool RendererSceneRender::is_compositor(RID p_rid) const {
237
	return compositor_storage.is_compositor(p_rid);
238
}
239

240
void RendererSceneRender::compositor_set_compositor_effects(RID p_compositor, const TypedArray<RID> &p_effects) {
241
	Vector<RID> rids;
242
	for (int i = 0; i < p_effects.size(); i++) {
243
		RID rid = p_effects[i];
244
		rids.push_back(rid);
245
	}
246

247
	compositor_storage.compositor_set_compositor_effects(p_compositor, rids);
248
}
249

250
/* Environment API */
251

252
RID RendererSceneRender::environment_allocate() {
253
	return environment_storage.environment_allocate();
254
}
255

256
void RendererSceneRender::environment_initialize(RID p_rid) {
257
	environment_storage.environment_initialize(p_rid);
258
}
259

260
void RendererSceneRender::environment_free(RID p_rid) {
261
	environment_storage.environment_free(p_rid);
262
}
263

264
bool RendererSceneRender::is_environment(RID p_rid) const {
265
	return environment_storage.is_environment(p_rid);
266
}
267

268
// background
269

270
void RendererSceneRender::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
271
	environment_storage.environment_set_background(p_env, p_bg);
272
}
273

274
void RendererSceneRender::environment_set_sky(RID p_env, RID p_sky) {
275
	environment_storage.environment_set_sky(p_env, p_sky);
276
}
277

278
void RendererSceneRender::environment_set_sky_custom_fov(RID p_env, float p_scale) {
279
	environment_storage.environment_set_sky_custom_fov(p_env, p_scale);
280
}
281

282
void RendererSceneRender::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
283
	environment_storage.environment_set_sky_orientation(p_env, p_orientation);
284
}
285

286
void RendererSceneRender::environment_set_bg_color(RID p_env, const Color &p_color) {
287
	environment_storage.environment_set_bg_color(p_env, p_color);
288
}
289

290
void RendererSceneRender::environment_set_bg_energy(RID p_env, float p_multiplier, float p_exposure_value) {
291
	environment_storage.environment_set_bg_energy(p_env, p_multiplier, p_exposure_value);
292
}
293

294
void RendererSceneRender::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
295
	environment_storage.environment_set_canvas_max_layer(p_env, p_max_layer);
296
}
297

298
void RendererSceneRender::environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient, float p_energy, float p_sky_contribution, RS::EnvironmentReflectionSource p_reflection_source) {
299
	environment_storage.environment_set_ambient_light(p_env, p_color, p_ambient, p_energy, p_sky_contribution, p_reflection_source);
300
}
301

302
RS::EnvironmentBG RendererSceneRender::environment_get_background(RID p_env) const {
303
	return environment_storage.environment_get_background(p_env);
304
}
305

306
RID RendererSceneRender::environment_get_sky(RID p_env) const {
307
	return environment_storage.environment_get_sky(p_env);
308
}
309

310
float RendererSceneRender::environment_get_sky_custom_fov(RID p_env) const {
311
	return environment_storage.environment_get_sky_custom_fov(p_env);
312
}
313

314
Basis RendererSceneRender::environment_get_sky_orientation(RID p_env) const {
315
	return environment_storage.environment_get_sky_orientation(p_env);
316
}
317

318
Color RendererSceneRender::environment_get_bg_color(RID p_env) const {
319
	return environment_storage.environment_get_bg_color(p_env);
320
}
321

322
float RendererSceneRender::environment_get_bg_energy_multiplier(RID p_env) const {
323
	return environment_storage.environment_get_bg_energy_multiplier(p_env);
324
}
325

326
float RendererSceneRender::environment_get_bg_intensity(RID p_env) const {
327
	return environment_storage.environment_get_bg_intensity(p_env);
328
}
329

330
int RendererSceneRender::environment_get_canvas_max_layer(RID p_env) const {
331
	return environment_storage.environment_get_canvas_max_layer(p_env);
332
}
333

334
RS::EnvironmentAmbientSource RendererSceneRender::environment_get_ambient_source(RID p_env) const {
335
	return environment_storage.environment_get_ambient_source(p_env);
336
}
337

338
Color RendererSceneRender::environment_get_ambient_light(RID p_env) const {
339
	return environment_storage.environment_get_ambient_light(p_env);
340
}
341

342
float RendererSceneRender::environment_get_ambient_light_energy(RID p_env) const {
343
	return environment_storage.environment_get_ambient_light_energy(p_env);
344
}
345

346
float RendererSceneRender::environment_get_ambient_sky_contribution(RID p_env) const {
347
	return environment_storage.environment_get_ambient_sky_contribution(p_env);
348
}
349

350
RS::EnvironmentReflectionSource RendererSceneRender::environment_get_reflection_source(RID p_env) const {
351
	return environment_storage.environment_get_reflection_source(p_env);
352
}
353

354
void RendererSceneRender::environment_set_camera_feed_id(RID p_env, int p_camera_feed_id) {
355
	environment_storage.environment_set_camera_feed_id(p_env, p_camera_feed_id);
356
}
357

358
int RendererSceneRender::environment_get_camera_feed_id(RID p_env) const {
359
	return environment_storage.environment_get_camera_feed_id(p_env);
360
}
361

362
// Tonemap
363

364
void RendererSceneRender::environment_set_tonemap(RID p_env, RS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white) {
365
	environment_storage.environment_set_tonemap(p_env, p_tone_mapper, p_exposure, p_white);
366
}
367

368
RS::EnvironmentToneMapper RendererSceneRender::environment_get_tone_mapper(RID p_env) const {
369
	return environment_storage.environment_get_tone_mapper(p_env);
370
}
371

372
float RendererSceneRender::environment_get_exposure(RID p_env) const {
373
	return environment_storage.environment_get_exposure(p_env);
374
}
375

376
float RendererSceneRender::environment_get_white(RID p_env) const {
377
	return environment_storage.environment_get_white(p_env);
378
}
379

380
// Fog
381

382
void RendererSceneRender::environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective, float p_sky_affect, RS::EnvironmentFogMode p_mode) {
383
	environment_storage.environment_set_fog(p_env, p_enable, p_light_color, p_light_energy, p_sun_scatter, p_density, p_height, p_height_density, p_aerial_perspective, p_sky_affect, p_mode);
384
}
385

386
bool RendererSceneRender::environment_get_fog_enabled(RID p_env) const {
387
	return environment_storage.environment_get_fog_enabled(p_env);
388
}
389

390
RS::EnvironmentFogMode RendererSceneRender::environment_get_fog_mode(RID p_env) const {
391
	return environment_storage.environment_get_fog_mode(p_env);
392
}
393

394
Color RendererSceneRender::environment_get_fog_light_color(RID p_env) const {
395
	return environment_storage.environment_get_fog_light_color(p_env);
396
}
397

398
float RendererSceneRender::environment_get_fog_light_energy(RID p_env) const {
399
	return environment_storage.environment_get_fog_light_energy(p_env);
400
}
401

402
float RendererSceneRender::environment_get_fog_sun_scatter(RID p_env) const {
403
	return environment_storage.environment_get_fog_sun_scatter(p_env);
404
}
405

406
float RendererSceneRender::environment_get_fog_density(RID p_env) const {
407
	return environment_storage.environment_get_fog_density(p_env);
408
}
409

410
float RendererSceneRender::environment_get_fog_sky_affect(RID p_env) const {
411
	return environment_storage.environment_get_fog_sky_affect(p_env);
412
}
413

414
float RendererSceneRender::environment_get_fog_height(RID p_env) const {
415
	return environment_storage.environment_get_fog_height(p_env);
416
}
417

418
float RendererSceneRender::environment_get_fog_height_density(RID p_env) const {
419
	return environment_storage.environment_get_fog_height_density(p_env);
420
}
421

422
float RendererSceneRender::environment_get_fog_aerial_perspective(RID p_env) const {
423
	return environment_storage.environment_get_fog_aerial_perspective(p_env);
424
}
425

426
// Depth Fog
427

428
void RendererSceneRender::environment_set_fog_depth(RID p_env, float p_curve, float p_begin, float p_end) {
429
	environment_storage.environment_set_fog_depth(p_env, p_curve, p_begin, p_end);
430
}
431

432
float RendererSceneRender::environment_get_fog_depth_curve(RID p_env) const {
433
	return environment_storage.environment_get_fog_depth_curve(p_env);
434
}
435

436
float RendererSceneRender::environment_get_fog_depth_begin(RID p_env) const {
437
	return environment_storage.environment_get_fog_depth_begin(p_env);
438
}
439

440
float RendererSceneRender::environment_get_fog_depth_end(RID p_env) const {
441
	return environment_storage.environment_get_fog_depth_end(p_env);
442
}
443

444
// Volumetric Fog
445

446
void RendererSceneRender::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_albedo, const Color &p_emission, float p_emission_energy, float p_anisotropy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount, float p_ambient_inject, float p_sky_affect) {
447
	environment_storage.environment_set_volumetric_fog(p_env, p_enable, p_density, p_albedo, p_emission, p_emission_energy, p_anisotropy, p_length, p_detail_spread, p_gi_inject, p_temporal_reprojection, p_temporal_reprojection_amount, p_ambient_inject, p_sky_affect);
448
}
449

450
bool RendererSceneRender::environment_get_volumetric_fog_enabled(RID p_env) const {
451
	return environment_storage.environment_get_volumetric_fog_enabled(p_env);
452
}
453

454
float RendererSceneRender::environment_get_volumetric_fog_density(RID p_env) const {
455
	return environment_storage.environment_get_volumetric_fog_density(p_env);
456
}
457

458
Color RendererSceneRender::environment_get_volumetric_fog_scattering(RID p_env) const {
459
	return environment_storage.environment_get_volumetric_fog_scattering(p_env);
460
}
461

462
Color RendererSceneRender::environment_get_volumetric_fog_emission(RID p_env) const {
463
	return environment_storage.environment_get_volumetric_fog_emission(p_env);
464
}
465

466
float RendererSceneRender::environment_get_volumetric_fog_emission_energy(RID p_env) const {
467
	return environment_storage.environment_get_volumetric_fog_emission_energy(p_env);
468
}
469

470
float RendererSceneRender::environment_get_volumetric_fog_anisotropy(RID p_env) const {
471
	return environment_storage.environment_get_volumetric_fog_anisotropy(p_env);
472
}
473

474
float RendererSceneRender::environment_get_volumetric_fog_length(RID p_env) const {
475
	return environment_storage.environment_get_volumetric_fog_length(p_env);
476
}
477

478
float RendererSceneRender::environment_get_volumetric_fog_detail_spread(RID p_env) const {
479
	return environment_storage.environment_get_volumetric_fog_detail_spread(p_env);
480
}
481

482
float RendererSceneRender::environment_get_volumetric_fog_gi_inject(RID p_env) const {
483
	return environment_storage.environment_get_volumetric_fog_gi_inject(p_env);
484
}
485

486
float RendererSceneRender::environment_get_volumetric_fog_sky_affect(RID p_env) const {
487
	return environment_storage.environment_get_volumetric_fog_sky_affect(p_env);
488
}
489

490
bool RendererSceneRender::environment_get_volumetric_fog_temporal_reprojection(RID p_env) const {
491
	return environment_storage.environment_get_volumetric_fog_temporal_reprojection(p_env);
492
}
493

494
float RendererSceneRender::environment_get_volumetric_fog_temporal_reprojection_amount(RID p_env) const {
495
	return environment_storage.environment_get_volumetric_fog_temporal_reprojection_amount(p_env);
496
}
497

498
float RendererSceneRender::environment_get_volumetric_fog_ambient_inject(RID p_env) const {
499
	return environment_storage.environment_get_volumetric_fog_ambient_inject(p_env);
500
}
501

502
// GLOW
503

504
void RendererSceneRender::environment_set_glow(RID p_env, bool p_enable, Vector<float> p_levels, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, RS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap, float p_glow_map_strength, RID p_glow_map) {
505
	environment_storage.environment_set_glow(p_env, p_enable, p_levels, p_intensity, p_strength, p_mix, p_bloom_threshold, p_blend_mode, p_hdr_bleed_threshold, p_hdr_bleed_scale, p_hdr_luminance_cap, p_glow_map_strength, p_glow_map);
506
}
507

508
bool RendererSceneRender::environment_get_glow_enabled(RID p_env) const {
509
	return environment_storage.environment_get_glow_enabled(p_env);
510
}
511

512
Vector<float> RendererSceneRender::environment_get_glow_levels(RID p_env) const {
513
	return environment_storage.environment_get_glow_levels(p_env);
514
}
515

516
float RendererSceneRender::environment_get_glow_intensity(RID p_env) const {
517
	return environment_storage.environment_get_glow_intensity(p_env);
518
}
519

520
float RendererSceneRender::environment_get_glow_strength(RID p_env) const {
521
	return environment_storage.environment_get_glow_strength(p_env);
522
}
523

524
float RendererSceneRender::environment_get_glow_bloom(RID p_env) const {
525
	return environment_storage.environment_get_glow_bloom(p_env);
526
}
527

528
float RendererSceneRender::environment_get_glow_mix(RID p_env) const {
529
	return environment_storage.environment_get_glow_mix(p_env);
530
}
531

532
RS::EnvironmentGlowBlendMode RendererSceneRender::environment_get_glow_blend_mode(RID p_env) const {
533
	return environment_storage.environment_get_glow_blend_mode(p_env);
534
}
535

536
float RendererSceneRender::environment_get_glow_hdr_bleed_threshold(RID p_env) const {
537
	return environment_storage.environment_get_glow_hdr_bleed_threshold(p_env);
538
}
539

540
float RendererSceneRender::environment_get_glow_hdr_luminance_cap(RID p_env) const {
541
	return environment_storage.environment_get_glow_hdr_luminance_cap(p_env);
542
}
543

544
float RendererSceneRender::environment_get_glow_hdr_bleed_scale(RID p_env) const {
545
	return environment_storage.environment_get_glow_hdr_bleed_scale(p_env);
546
}
547

548
float RendererSceneRender::environment_get_glow_map_strength(RID p_env) const {
549
	return environment_storage.environment_get_glow_map_strength(p_env);
550
}
551

552
RID RendererSceneRender::environment_get_glow_map(RID p_env) const {
553
	return environment_storage.environment_get_glow_map(p_env);
554
}
555

556
// SSR
557

558
void RendererSceneRender::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_fade_int, float p_fade_out, float p_depth_tolerance) {
559
	environment_storage.environment_set_ssr(p_env, p_enable, p_max_steps, p_fade_int, p_fade_out, p_depth_tolerance);
560
}
561

562
bool RendererSceneRender::environment_get_ssr_enabled(RID p_env) const {
563
	return environment_storage.environment_get_ssr_enabled(p_env);
564
}
565

566
int RendererSceneRender::environment_get_ssr_max_steps(RID p_env) const {
567
	return environment_storage.environment_get_ssr_max_steps(p_env);
568
}
569

570
float RendererSceneRender::environment_get_ssr_fade_in(RID p_env) const {
571
	return environment_storage.environment_get_ssr_fade_in(p_env);
572
}
573

574
float RendererSceneRender::environment_get_ssr_fade_out(RID p_env) const {
575
	return environment_storage.environment_get_ssr_fade_out(p_env);
576
}
577

578
float RendererSceneRender::environment_get_ssr_depth_tolerance(RID p_env) const {
579
	return environment_storage.environment_get_ssr_depth_tolerance(p_env);
580
}
581

582
// SSAO
583

584
void RendererSceneRender::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_power, float p_detail, float p_horizon, float p_sharpness, float p_light_affect, float p_ao_channel_affect) {
585
	environment_storage.environment_set_ssao(p_env, p_enable, p_radius, p_intensity, p_power, p_detail, p_horizon, p_sharpness, p_light_affect, p_ao_channel_affect);
586
}
587

588
bool RendererSceneRender::environment_get_ssao_enabled(RID p_env) const {
589
	return environment_storage.environment_get_ssao_enabled(p_env);
590
}
591

592
float RendererSceneRender::environment_get_ssao_radius(RID p_env) const {
593
	return environment_storage.environment_get_ssao_radius(p_env);
594
}
595

596
float RendererSceneRender::environment_get_ssao_intensity(RID p_env) const {
597
	return environment_storage.environment_get_ssao_intensity(p_env);
598
}
599

600
float RendererSceneRender::environment_get_ssao_power(RID p_env) const {
601
	return environment_storage.environment_get_ssao_power(p_env);
602
}
603

604
float RendererSceneRender::environment_get_ssao_detail(RID p_env) const {
605
	return environment_storage.environment_get_ssao_detail(p_env);
606
}
607

608
float RendererSceneRender::environment_get_ssao_horizon(RID p_env) const {
609
	return environment_storage.environment_get_ssao_horizon(p_env);
610
}
611

612
float RendererSceneRender::environment_get_ssao_sharpness(RID p_env) const {
613
	return environment_storage.environment_get_ssao_sharpness(p_env);
614
}
615

616
float RendererSceneRender::environment_get_ssao_direct_light_affect(RID p_env) const {
617
	return environment_storage.environment_get_ssao_direct_light_affect(p_env);
618
}
619

620
float RendererSceneRender::environment_get_ssao_ao_channel_affect(RID p_env) const {
621
	return environment_storage.environment_get_ssao_ao_channel_affect(p_env);
622
}
623

624
// SSIL
625

626
void RendererSceneRender::environment_set_ssil(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_sharpness, float p_normal_rejection) {
627
	environment_storage.environment_set_ssil(p_env, p_enable, p_radius, p_intensity, p_sharpness, p_normal_rejection);
628
}
629

630
bool RendererSceneRender::environment_get_ssil_enabled(RID p_env) const {
631
	return environment_storage.environment_get_ssil_enabled(p_env);
632
}
633

634
float RendererSceneRender::environment_get_ssil_radius(RID p_env) const {
635
	return environment_storage.environment_get_ssil_radius(p_env);
636
}
637

638
float RendererSceneRender::environment_get_ssil_intensity(RID p_env) const {
639
	return environment_storage.environment_get_ssil_intensity(p_env);
640
}
641

642
float RendererSceneRender::environment_get_ssil_sharpness(RID p_env) const {
643
	return environment_storage.environment_get_ssil_sharpness(p_env);
644
}
645

646
float RendererSceneRender::environment_get_ssil_normal_rejection(RID p_env) const {
647
	return environment_storage.environment_get_ssil_normal_rejection(p_env);
648
}
649

650
// SDFGI
651

652
void RendererSceneRender::environment_set_sdfgi(RID p_env, bool p_enable, int p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, float p_bounce_feedback, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
653
	environment_storage.environment_set_sdfgi(p_env, p_enable, p_cascades, p_min_cell_size, p_y_scale, p_use_occlusion, p_bounce_feedback, p_read_sky, p_energy, p_normal_bias, p_probe_bias);
654
}
655

656
bool RendererSceneRender::environment_get_sdfgi_enabled(RID p_env) const {
657
	return environment_storage.environment_get_sdfgi_enabled(p_env);
658
}
659

660
int RendererSceneRender::environment_get_sdfgi_cascades(RID p_env) const {
661
	return environment_storage.environment_get_sdfgi_cascades(p_env);
662
}
663

664
float RendererSceneRender::environment_get_sdfgi_min_cell_size(RID p_env) const {
665
	return environment_storage.environment_get_sdfgi_min_cell_size(p_env);
666
}
667

668
bool RendererSceneRender::environment_get_sdfgi_use_occlusion(RID p_env) const {
669
	return environment_storage.environment_get_sdfgi_use_occlusion(p_env);
670
}
671

672
float RendererSceneRender::environment_get_sdfgi_bounce_feedback(RID p_env) const {
673
	return environment_storage.environment_get_sdfgi_bounce_feedback(p_env);
674
}
675

676
bool RendererSceneRender::environment_get_sdfgi_read_sky_light(RID p_env) const {
677
	return environment_storage.environment_get_sdfgi_read_sky_light(p_env);
678
}
679

680
float RendererSceneRender::environment_get_sdfgi_energy(RID p_env) const {
681
	return environment_storage.environment_get_sdfgi_energy(p_env);
682
}
683

684
float RendererSceneRender::environment_get_sdfgi_normal_bias(RID p_env) const {
685
	return environment_storage.environment_get_sdfgi_normal_bias(p_env);
686
}
687

688
float RendererSceneRender::environment_get_sdfgi_probe_bias(RID p_env) const {
689
	return environment_storage.environment_get_sdfgi_probe_bias(p_env);
690
}
691

692
RS::EnvironmentSDFGIYScale RendererSceneRender::environment_get_sdfgi_y_scale(RID p_env) const {
693
	return environment_storage.environment_get_sdfgi_y_scale(p_env);
694
}
695

696
// Adjustments
697

698
void RendererSceneRender::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, bool p_use_1d_color_correction, RID p_color_correction) {
699
	environment_storage.environment_set_adjustment(p_env, p_enable, p_brightness, p_contrast, p_saturation, p_use_1d_color_correction, p_color_correction);
700
}
701

702
bool RendererSceneRender::environment_get_adjustments_enabled(RID p_env) const {
703
	return environment_storage.environment_get_adjustments_enabled(p_env);
704
}
705

706
float RendererSceneRender::environment_get_adjustments_brightness(RID p_env) const {
707
	return environment_storage.environment_get_adjustments_brightness(p_env);
708
}
709

710
float RendererSceneRender::environment_get_adjustments_contrast(RID p_env) const {
711
	return environment_storage.environment_get_adjustments_contrast(p_env);
712
}
713

714
float RendererSceneRender::environment_get_adjustments_saturation(RID p_env) const {
715
	return environment_storage.environment_get_adjustments_saturation(p_env);
716
}
717

718
bool RendererSceneRender::environment_get_use_1d_color_correction(RID p_env) const {
719
	return environment_storage.environment_get_use_1d_color_correction(p_env);
720
}
721

722
RID RendererSceneRender::environment_get_color_correction(RID p_env) const {
723
	return environment_storage.environment_get_color_correction(p_env);
724
}
725

726
Product

Resources

Company
