1 /*************************************************************************/
2 /* visual_server_raster.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
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 #include "visual_server_raster.h"
31 #include "globals.h"
32 #include "io/marshalls.h"
33 #include "os/os.h"
34 #include "sort.h"
35 // careful, these may run in different threads than the visual server
36
37 BalloonAllocator<> *VisualServerRaster::OctreeAllocator::allocator = NULL;
38
39 #define VS_CHANGED \
40 changes++;
41
42 // print_line(__FUNCTION__);
43
texture_create()44 RID VisualServerRaster::texture_create() {
45
46 return rasterizer->texture_create();
47 }
48
texture_allocate(RID p_texture,int p_width,int p_height,Image::Format p_format,uint32_t p_flags)49 void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags) {
50
51 rasterizer->texture_allocate(p_texture, p_width, p_height, p_format, p_flags);
52 }
53
texture_set_flags(RID p_texture,uint32_t p_flags)54 void VisualServerRaster::texture_set_flags(RID p_texture, uint32_t p_flags) {
55
56 VS_CHANGED;
57 rasterizer->texture_set_flags(p_texture, p_flags);
58 }
59
texture_set_data(RID p_texture,const Image & p_image,CubeMapSide p_cube_side)60 void VisualServerRaster::texture_set_data(RID p_texture, const Image &p_image, CubeMapSide p_cube_side) {
61
62 VS_CHANGED;
63 rasterizer->texture_set_data(p_texture, p_image, p_cube_side);
64 }
65
texture_get_data(RID p_texture,CubeMapSide p_cube_side) const66 Image VisualServerRaster::texture_get_data(RID p_texture, CubeMapSide p_cube_side) const {
67
68 return rasterizer->texture_get_data(p_texture, p_cube_side);
69 }
70
texture_get_flags(RID p_texture) const71 uint32_t VisualServerRaster::texture_get_flags(RID p_texture) const {
72
73 return rasterizer->texture_get_flags(p_texture);
74 }
texture_get_format(RID p_texture) const75 Image::Format VisualServerRaster::texture_get_format(RID p_texture) const {
76
77 return rasterizer->texture_get_format(p_texture);
78 }
texture_get_width(RID p_texture) const79 uint32_t VisualServerRaster::texture_get_width(RID p_texture) const {
80
81 return rasterizer->texture_get_width(p_texture);
82 }
83
texture_get_height(RID p_texture) const84 uint32_t VisualServerRaster::texture_get_height(RID p_texture) const {
85
86 return rasterizer->texture_get_height(p_texture);
87 }
88
texture_set_size_override(RID p_texture,int p_width,int p_height)89 void VisualServerRaster::texture_set_size_override(RID p_texture, int p_width, int p_height) {
90
91 rasterizer->texture_set_size_override(p_texture, p_width, p_height);
92 }
93
texture_can_stream(RID p_texture) const94 bool VisualServerRaster::texture_can_stream(RID p_texture) const {
95
96 return false;
97 }
98
texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName & p_function) const99 void VisualServerRaster::texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function) const {
100
101 rasterizer->texture_set_reload_hook(p_texture, p_owner, p_function);
102 }
103
texture_set_path(RID p_texture,const String & p_path)104 void VisualServerRaster::texture_set_path(RID p_texture, const String &p_path) {
105
106 rasterizer->texture_set_path(p_texture, p_path);
107 }
108
texture_get_path(RID p_texture) const109 String VisualServerRaster::texture_get_path(RID p_texture) const {
110
111 return rasterizer->texture_get_path(p_texture);
112 }
113
texture_debug_usage(List<TextureInfo> * r_info)114 void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info) {
115
116 rasterizer->texture_debug_usage(r_info);
117 }
118
texture_set_shrink_all_x2_on_set_data(bool p_enable)119 void VisualServerRaster::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
120
121 rasterizer->texture_set_shrink_all_x2_on_set_data(p_enable);
122 }
123
124 /* SHADER API */
125
shader_create(ShaderMode p_mode)126 RID VisualServerRaster::shader_create(ShaderMode p_mode) {
127
128 return rasterizer->shader_create(p_mode);
129 }
130
shader_set_mode(RID p_shader,ShaderMode p_mode)131 void VisualServerRaster::shader_set_mode(RID p_shader, ShaderMode p_mode) {
132
133 VS_CHANGED;
134 rasterizer->shader_set_mode(p_shader, p_mode);
135 }
shader_get_mode(RID p_shader) const136 VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader) const {
137
138 return rasterizer->shader_get_mode(p_shader);
139 }
140
shader_set_code(RID p_shader,const String & p_vertex,const String & p_fragment,const String & p_light,int p_vertex_ofs,int p_fragment_ofs,int p_light_ofs)141 void VisualServerRaster::shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs, int p_fragment_ofs, int p_light_ofs) {
142
143 VS_CHANGED;
144 rasterizer->shader_set_code(p_shader, p_vertex, p_fragment, p_light, p_vertex_ofs, p_fragment_ofs, p_light_ofs);
145 }
146
shader_get_vertex_code(RID p_shader) const147 String VisualServerRaster::shader_get_vertex_code(RID p_shader) const {
148
149 return rasterizer->shader_get_vertex_code(p_shader);
150 }
151
shader_get_fragment_code(RID p_shader) const152 String VisualServerRaster::shader_get_fragment_code(RID p_shader) const {
153
154 return rasterizer->shader_get_fragment_code(p_shader);
155 }
156
shader_get_light_code(RID p_shader) const157 String VisualServerRaster::shader_get_light_code(RID p_shader) const {
158
159 return rasterizer->shader_get_light_code(p_shader);
160 }
161
shader_get_param_list(RID p_shader,List<PropertyInfo> * p_param_list) const162 void VisualServerRaster::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
163
164 return rasterizer->shader_get_param_list(p_shader, p_param_list);
165 }
166
shader_set_default_texture_param(RID p_shader,const StringName & p_name,RID p_texture)167 void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
168
169 rasterizer->shader_set_default_texture_param(p_shader, p_name, p_texture);
170 }
171
shader_get_default_texture_param(RID p_shader,const StringName & p_name) const172 RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
173
174 return rasterizer->shader_get_default_texture_param(p_shader, p_name);
175 }
176
177 /* Material */
178
material_create()179 RID VisualServerRaster::material_create() {
180
181 return rasterizer->material_create();
182 }
183
material_set_shader(RID p_material,RID p_shader)184 void VisualServerRaster::material_set_shader(RID p_material, RID p_shader) {
185
186 VS_CHANGED;
187 rasterizer->material_set_shader(p_material, p_shader);
188 }
189
material_get_shader(RID p_material) const190 RID VisualServerRaster::material_get_shader(RID p_material) const {
191
192 return rasterizer->material_get_shader(p_material);
193 }
194
material_set_param(RID p_material,const StringName & p_param,const Variant & p_value)195 void VisualServerRaster::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
196
197 VS_CHANGED;
198 rasterizer->material_set_param(p_material, p_param, p_value);
199 }
200
material_get_param(RID p_material,const StringName & p_param) const201 Variant VisualServerRaster::material_get_param(RID p_material, const StringName &p_param) const {
202
203 return rasterizer->material_get_param(p_material, p_param);
204 }
205
material_set_flag(RID p_material,MaterialFlag p_flag,bool p_enabled)206 void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag, bool p_enabled) {
207 VS_CHANGED;
208 rasterizer->material_set_flag(p_material, p_flag, p_enabled);
209 }
210
material_set_depth_draw_mode(RID p_material,MaterialDepthDrawMode p_mode)211 void VisualServerRaster::material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode) {
212
213 VS_CHANGED;
214 rasterizer->material_set_depth_draw_mode(p_material, p_mode);
215 }
216
material_get_depth_draw_mode(RID p_material) const217 VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p_material) const {
218
219 return rasterizer->material_get_depth_draw_mode(p_material);
220 }
221
material_get_flag(RID p_material,MaterialFlag p_flag) const222 bool VisualServerRaster::material_get_flag(RID p_material, MaterialFlag p_flag) const {
223
224 return rasterizer->material_get_flag(p_material, p_flag);
225 }
226
material_set_blend_mode(RID p_material,MaterialBlendMode p_mode)227 void VisualServerRaster::material_set_blend_mode(RID p_material, MaterialBlendMode p_mode) {
228 VS_CHANGED;
229 rasterizer->material_set_blend_mode(p_material, p_mode);
230 }
material_get_blend_mode(RID p_material) const231 VS::MaterialBlendMode VisualServerRaster::material_get_blend_mode(RID p_material) const {
232
233 return rasterizer->material_get_blend_mode(p_material);
234 }
235
material_set_line_width(RID p_material,float p_line_width)236 void VisualServerRaster::material_set_line_width(RID p_material, float p_line_width) {
237 VS_CHANGED;
238 rasterizer->material_set_line_width(p_material, p_line_width);
239 }
material_get_line_width(RID p_material) const240 float VisualServerRaster::material_get_line_width(RID p_material) const {
241
242 return rasterizer->material_get_line_width(p_material);
243 }
244
245 /* FIXED MATERIAL */
246
fixed_material_create()247 RID VisualServerRaster::fixed_material_create() {
248
249 return rasterizer->fixed_material_create();
250 }
251
fixed_material_set_flag(RID p_material,FixedMaterialFlags p_flag,bool p_enabled)252 void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled) {
253
254 rasterizer->fixed_material_set_flag(p_material, p_flag, p_enabled);
255 }
256
fixed_material_get_flag(RID p_material,FixedMaterialFlags p_flag) const257 bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag) const {
258
259 return rasterizer->fixed_material_get_flag(p_material, p_flag);
260 }
261
fixed_material_set_param(RID p_material,FixedMaterialParam p_parameter,const Variant & p_value)262 void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant &p_value) {
263 VS_CHANGED;
264 rasterizer->fixed_material_set_parameter(p_material, p_parameter, p_value);
265 }
266
fixed_material_get_param(RID p_material,FixedMaterialParam p_parameter) const267 Variant VisualServerRaster::fixed_material_get_param(RID p_material, FixedMaterialParam p_parameter) const {
268
269 return rasterizer->fixed_material_get_parameter(p_material, p_parameter);
270 }
271
fixed_material_set_texture(RID p_material,FixedMaterialParam p_parameter,RID p_texture)272 void VisualServerRaster::fixed_material_set_texture(RID p_material, FixedMaterialParam p_parameter, RID p_texture) {
273 VS_CHANGED;
274 rasterizer->fixed_material_set_texture(p_material, p_parameter, p_texture);
275 }
276
fixed_material_get_texture(RID p_material,FixedMaterialParam p_parameter) const277 RID VisualServerRaster::fixed_material_get_texture(RID p_material, FixedMaterialParam p_parameter) const {
278
279 return rasterizer->fixed_material_get_texture(p_material, p_parameter);
280 }
281
fixed_material_set_texcoord_mode(RID p_material,FixedMaterialParam p_parameter,FixedMaterialTexCoordMode p_mode)282 void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material, FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode) {
283 VS_CHANGED;
284 rasterizer->fixed_material_set_texcoord_mode(p_material, p_parameter, p_mode);
285 }
286
fixed_material_get_texcoord_mode(RID p_material,FixedMaterialParam p_parameter) const287 VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material, FixedMaterialParam p_parameter) const {
288
289 return rasterizer->fixed_material_get_texcoord_mode(p_material, p_parameter);
290 }
291
fixed_material_set_point_size(RID p_material,float p_size)292 void VisualServerRaster::fixed_material_set_point_size(RID p_material, float p_size) {
293 VS_CHANGED
294
295 rasterizer->fixed_material_set_point_size(p_material, p_size);
296 }
297
fixed_material_get_point_size(RID p_material) const298 float VisualServerRaster::fixed_material_get_point_size(RID p_material) const {
299
300 return rasterizer->fixed_material_get_point_size(p_material);
301 }
302
fixed_material_set_uv_transform(RID p_material,const Transform & p_transform)303 void VisualServerRaster::fixed_material_set_uv_transform(RID p_material, const Transform &p_transform) {
304 VS_CHANGED;
305 rasterizer->fixed_material_set_uv_transform(p_material, p_transform);
306 }
307
fixed_material_get_uv_transform(RID p_material) const308 Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) const {
309
310 return rasterizer->fixed_material_get_uv_transform(p_material);
311 }
312
fixed_material_set_light_shader(RID p_material,FixedMaterialLightShader p_shader)313 void VisualServerRaster::fixed_material_set_light_shader(RID p_material, FixedMaterialLightShader p_shader) {
314
315 VS_CHANGED;
316 rasterizer->fixed_material_set_light_shader(p_material, p_shader);
317 }
318
fixed_material_get_light_shader(RID p_material) const319 VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const {
320
321 return rasterizer->fixed_material_get_light_shader(p_material);
322 }
323
324 /* MESH API */
325
mesh_create()326 RID VisualServerRaster::mesh_create() {
327
328 return rasterizer->mesh_create();
329 }
330
mesh_set_morph_target_count(RID p_mesh,int p_amount)331 void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh, int p_amount) {
332
333 rasterizer->mesh_set_morph_target_count(p_mesh, p_amount);
334 int amount = rasterizer->mesh_get_morph_target_count(p_mesh);
335
336 Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_mesh);
337
338 if (!E)
339 return;
340
341 Set<RID>::Element *I = E->get().front();
342
343 while (I) {
344
345 Instance *ins = instance_owner.get(I->get());
346 ins->data.morph_values.resize(amount);
347 I = I->next();
348 }
349 }
350
mesh_get_morph_target_count(RID p_mesh) const351 int VisualServerRaster::mesh_get_morph_target_count(RID p_mesh) const {
352
353 return rasterizer->mesh_get_morph_target_count(p_mesh);
354 }
355
mesh_set_morph_target_mode(RID p_mesh,MorphTargetMode p_mode)356 void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh, MorphTargetMode p_mode) {
357
358 rasterizer->mesh_set_morph_target_mode(p_mesh, p_mode);
359 }
360
mesh_get_morph_target_mode(RID p_mesh) const361 VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh) const {
362
363 return rasterizer->mesh_get_morph_target_mode(p_mesh);
364 }
365
mesh_add_custom_surface(RID p_mesh,const Variant & p_dat)366 void VisualServerRaster::mesh_add_custom_surface(RID p_mesh, const Variant &p_dat) {
367 }
368
mesh_add_surface(RID p_mesh,PrimitiveType p_primitive,const Array & p_arrays,const Array & p_blend_shapes,bool p_alpha_sort)369 void VisualServerRaster::mesh_add_surface(RID p_mesh, PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, bool p_alpha_sort) {
370
371 VS_CHANGED;
372 _dependency_queue_update(p_mesh, true, true);
373 rasterizer->mesh_add_surface(p_mesh, p_primitive, p_arrays, p_blend_shapes, p_alpha_sort);
374 }
375
mesh_get_surface_arrays(RID p_mesh,int p_surface) const376 Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh, int p_surface) const {
377
378 return rasterizer->mesh_get_surface_arrays(p_mesh, p_surface);
379 }
mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const380 Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh, int p_surface) const {
381
382 return rasterizer->mesh_get_surface_morph_arrays(p_mesh, p_surface);
383 }
384
mesh_surface_set_material(RID p_mesh,int p_surface,RID p_material,bool p_owned)385 void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned) {
386 VS_CHANGED;
387 rasterizer->mesh_surface_set_material(p_mesh, p_surface, p_material, p_owned);
388 }
389
mesh_surface_get_material(RID p_mesh,int p_surface) const390 RID VisualServerRaster::mesh_surface_get_material(RID p_mesh, int p_surface) const {
391
392 return rasterizer->mesh_surface_get_material(p_mesh, p_surface);
393 }
394
mesh_surface_get_array_len(RID p_mesh,int p_surface) const395 int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface) const {
396
397 return rasterizer->mesh_surface_get_array_len(p_mesh, p_surface);
398 }
399
mesh_surface_get_array_index_len(RID p_mesh,int p_surface) const400 int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const {
401
402 return rasterizer->mesh_surface_get_array_index_len(p_mesh, p_surface);
403 }
404
mesh_surface_get_format(RID p_mesh,int p_surface) const405 uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface) const {
406
407 return rasterizer->mesh_surface_get_format(p_mesh, p_surface);
408 }
409
mesh_surface_get_primitive_type(RID p_mesh,int p_surface) const410 VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const {
411
412 return rasterizer->mesh_surface_get_primitive_type(p_mesh, p_surface);
413 }
414
mesh_remove_surface(RID p_mesh,int p_surface)415 void VisualServerRaster::mesh_remove_surface(RID p_mesh, int p_surface) {
416
417 rasterizer->mesh_remove_surface(p_mesh, p_surface);
418 _dependency_queue_update(p_mesh, true, true);
419 }
420
mesh_get_surface_count(RID p_mesh) const421 int VisualServerRaster::mesh_get_surface_count(RID p_mesh) const {
422
423 return rasterizer->mesh_get_surface_count(p_mesh);
424 }
425
mesh_set_custom_aabb(RID p_mesh,const AABB & p_aabb)426 void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
427
428 VS_CHANGED;
429 _dependency_queue_update(p_mesh, true);
430 rasterizer->mesh_set_custom_aabb(p_mesh, p_aabb);
431 }
432
mesh_get_custom_aabb(RID p_mesh) const433 AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh) const {
434
435 return rasterizer->mesh_get_custom_aabb(p_mesh);
436 }
437
mesh_clear(RID p_mesh)438 void VisualServerRaster::mesh_clear(RID p_mesh) {
439
440 ERR_FAIL_COND(!rasterizer->is_mesh(p_mesh));
441 while (rasterizer->mesh_get_surface_count(p_mesh)) {
442 rasterizer->mesh_remove_surface(p_mesh, 0);
443 }
444
445 _dependency_queue_update(p_mesh, true, true);
446 }
447
448 /* MULTIMESH */
449
multimesh_create()450 RID VisualServerRaster::multimesh_create() {
451
452 return rasterizer->multimesh_create();
453 }
454
multimesh_set_instance_count(RID p_multimesh,int p_count)455 void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh, int p_count) {
456 VS_CHANGED;
457 rasterizer->multimesh_set_instance_count(p_multimesh, p_count);
458 }
459
multimesh_get_instance_count(RID p_multimesh) const460 int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh) const {
461
462 return rasterizer->multimesh_get_instance_count(p_multimesh);
463 }
464
multimesh_set_mesh(RID p_multimesh,RID p_mesh)465 void VisualServerRaster::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
466 VS_CHANGED;
467 rasterizer->multimesh_set_mesh(p_multimesh, p_mesh);
468 }
multimesh_set_aabb(RID p_multimesh,const AABB & p_aabb)469 void VisualServerRaster::multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb) {
470 VS_CHANGED;
471 rasterizer->multimesh_set_aabb(p_multimesh, p_aabb);
472 _dependency_queue_update(p_multimesh, true);
473 }
474
multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform & p_transform)475 void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
476 VS_CHANGED;
477 rasterizer->multimesh_instance_set_transform(p_multimesh, p_index, p_transform);
478 }
multimesh_instance_set_color(RID p_multimesh,int p_index,const Color & p_color)479 void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
480 VS_CHANGED;
481 rasterizer->multimesh_instance_set_color(p_multimesh, p_index, p_color);
482 }
multimesh_get_mesh(RID p_multimesh) const483 RID VisualServerRaster::multimesh_get_mesh(RID p_multimesh) const {
484
485 return rasterizer->multimesh_get_mesh(p_multimesh);
486 }
multimesh_get_aabb(RID p_multimesh,const AABB & p_aabb) const487 AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh, const AABB &p_aabb) const {
488
489 return rasterizer->multimesh_get_aabb(p_multimesh);
490 }
491
multimesh_instance_get_transform(RID p_multimesh,int p_index) const492 Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
493
494 return rasterizer->multimesh_instance_get_transform(p_multimesh, p_index);
495 }
multimesh_instance_get_color(RID p_multimesh,int p_index) const496 Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
497
498 return rasterizer->multimesh_instance_get_color(p_multimesh, p_index);
499 }
500
multimesh_set_visible_instances(RID p_multimesh,int p_visible)501 void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
502
503 rasterizer->multimesh_set_visible_instances(p_multimesh, p_visible);
504 }
505
multimesh_get_visible_instances(RID p_multimesh) const506 int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh) const {
507
508 return rasterizer->multimesh_get_visible_instances(p_multimesh);
509 }
510
511 /* IMMEDIATE API */
512
immediate_create()513 RID VisualServerRaster::immediate_create() {
514
515 return rasterizer->immediate_create();
516 }
517
immediate_begin(RID p_immediate,PrimitiveType p_primitive,RID p_texture)518 void VisualServerRaster::immediate_begin(RID p_immediate, PrimitiveType p_primitive, RID p_texture) {
519
520 rasterizer->immediate_begin(p_immediate, p_primitive, p_texture);
521 }
immediate_vertex(RID p_immediate,const Vector3 & p_vertex)522 void VisualServerRaster::immediate_vertex(RID p_immediate, const Vector3 &p_vertex) {
523
524 rasterizer->immediate_vertex(p_immediate, p_vertex);
525 }
immediate_normal(RID p_immediate,const Vector3 & p_normal)526 void VisualServerRaster::immediate_normal(RID p_immediate, const Vector3 &p_normal) {
527
528 rasterizer->immediate_normal(p_immediate, p_normal);
529 }
immediate_tangent(RID p_immediate,const Plane & p_tangent)530 void VisualServerRaster::immediate_tangent(RID p_immediate, const Plane &p_tangent) {
531
532 rasterizer->immediate_tangent(p_immediate, p_tangent);
533 }
immediate_color(RID p_immediate,const Color & p_color)534 void VisualServerRaster::immediate_color(RID p_immediate, const Color &p_color) {
535
536 rasterizer->immediate_color(p_immediate, p_color);
537 }
immediate_uv(RID p_immediate,const Vector2 & p_uv)538 void VisualServerRaster::immediate_uv(RID p_immediate, const Vector2 &p_uv) {
539
540 rasterizer->immediate_uv(p_immediate, p_uv);
541 }
immediate_uv2(RID p_immediate,const Vector2 & p_uv2)542 void VisualServerRaster::immediate_uv2(RID p_immediate, const Vector2 &p_uv2) {
543
544 rasterizer->immediate_uv2(p_immediate, p_uv2);
545 }
immediate_end(RID p_immediate)546 void VisualServerRaster::immediate_end(RID p_immediate) {
547
548 VS_CHANGED;
549 _dependency_queue_update(p_immediate, true);
550 rasterizer->immediate_end(p_immediate);
551 }
immediate_clear(RID p_immediate)552 void VisualServerRaster::immediate_clear(RID p_immediate) {
553
554 VS_CHANGED;
555 _dependency_queue_update(p_immediate, true);
556 rasterizer->immediate_clear(p_immediate);
557 }
558
immediate_set_material(RID p_immediate,RID p_material)559 void VisualServerRaster::immediate_set_material(RID p_immediate, RID p_material) {
560
561 rasterizer->immediate_set_material(p_immediate, p_material);
562 }
563
immediate_get_material(RID p_immediate) const564 RID VisualServerRaster::immediate_get_material(RID p_immediate) const {
565
566 return rasterizer->immediate_get_material(p_immediate);
567 }
568
569 /* PARTICLES API */
570
particles_create()571 RID VisualServerRaster::particles_create() {
572
573 return rasterizer->particles_create();
574 }
575
particles_set_amount(RID p_particles,int p_amount)576 void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount) {
577 VS_CHANGED;
578 rasterizer->particles_set_amount(p_particles, p_amount);
579 }
580
particles_get_amount(RID p_particles) const581 int VisualServerRaster::particles_get_amount(RID p_particles) const {
582
583 return rasterizer->particles_get_amount(p_particles);
584 }
585
particles_set_emitting(RID p_particles,bool p_emitting)586 void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting) {
587 VS_CHANGED;
588 rasterizer->particles_set_emitting(p_particles, p_emitting);
589 }
particles_is_emitting(RID p_particles) const590 bool VisualServerRaster::particles_is_emitting(RID p_particles) const {
591
592 return rasterizer->particles_is_emitting(p_particles);
593 }
594
particles_set_visibility_aabb(RID p_particles,const AABB & p_visibility)595 void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility) {
596 VS_CHANGED;
597 rasterizer->particles_set_visibility_aabb(p_particles, p_visibility);
598 }
particles_get_visibility_aabb(RID p_particles) const599 AABB VisualServerRaster::particles_get_visibility_aabb(RID p_particles) const {
600
601 return rasterizer->particles_get_visibility_aabb(p_particles);
602 }
603
particles_set_emission_half_extents(RID p_particles,const Vector3 & p_half_extents)604 void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents) {
605 VS_CHANGED;
606 rasterizer->particles_set_emission_half_extents(p_particles, p_half_extents);
607 }
particles_get_emission_half_extents(RID p_particles) const608 Vector3 VisualServerRaster::particles_get_emission_half_extents(RID p_particles) const {
609
610 return rasterizer->particles_get_emission_half_extents(p_particles);
611 }
612
particles_set_emission_base_velocity(RID p_particles,const Vector3 & p_base_velocity)613 void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity) {
614 VS_CHANGED;
615 rasterizer->particles_set_emission_base_velocity(p_particles, p_base_velocity);
616 }
particles_get_emission_base_velocity(RID p_particles) const617 Vector3 VisualServerRaster::particles_get_emission_base_velocity(RID p_particles) const {
618
619 return rasterizer->particles_get_emission_base_velocity(p_particles);
620 }
621
particles_set_emission_points(RID p_particles,const DVector<Vector3> & p_points)622 void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points) {
623
624 VS_CHANGED;
625 rasterizer->particles_set_emission_points(p_particles, p_points);
626 }
627
particles_get_emission_points(RID p_particles) const628 DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles) const {
629
630 return rasterizer->particles_get_emission_points(p_particles);
631 }
632
particles_set_gravity_normal(RID p_particles,const Vector3 & p_normal)633 void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal) {
634 VS_CHANGED;
635 rasterizer->particles_set_gravity_normal(p_particles, p_normal);
636 }
particles_get_gravity_normal(RID p_particles) const637 Vector3 VisualServerRaster::particles_get_gravity_normal(RID p_particles) const {
638
639 return rasterizer->particles_get_gravity_normal(p_particles);
640 }
641
particles_set_variable(RID p_particles,ParticleVariable p_variable,float p_value)642 void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable, float p_value) {
643 VS_CHANGED;
644 rasterizer->particles_set_variable(p_particles, p_variable, p_value);
645 }
particles_get_variable(RID p_particles,ParticleVariable p_variable) const646 float VisualServerRaster::particles_get_variable(RID p_particles, ParticleVariable p_variable) const {
647
648 return rasterizer->particles_get_variable(p_particles, p_variable);
649 }
650
particles_set_randomness(RID p_particles,ParticleVariable p_variable,float p_randomness)651 void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable, float p_randomness) {
652 VS_CHANGED;
653 rasterizer->particles_set_randomness(p_particles, p_variable, p_randomness);
654 }
particles_get_randomness(RID p_particles,ParticleVariable p_variable) const655 float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable) const {
656
657 return rasterizer->particles_get_randomness(p_particles, p_variable);
658 }
659
particles_set_color_phases(RID p_particles,int p_phases)660 void VisualServerRaster::particles_set_color_phases(RID p_particles, int p_phases) {
661 VS_CHANGED;
662 rasterizer->particles_set_color_phases(p_particles, p_phases);
663 }
particles_get_color_phases(RID p_particles) const664 int VisualServerRaster::particles_get_color_phases(RID p_particles) const {
665
666 return rasterizer->particles_get_color_phases(p_particles);
667 }
668
particles_set_color_phase_pos(RID p_particles,int p_phase,float p_pos)669 void VisualServerRaster::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos) {
670 VS_CHANGED;
671 rasterizer->particles_set_color_phase_pos(p_particles, p_phase, p_pos);
672 }
particles_get_color_phase_pos(RID p_particles,int p_phase) const673 float VisualServerRaster::particles_get_color_phase_pos(RID p_particles, int p_phase) const {
674
675 return rasterizer->particles_get_color_phase_pos(p_particles, p_phase);
676 }
677
particles_set_attractors(RID p_particles,int p_attractors)678 void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors) {
679 VS_CHANGED;
680 rasterizer->particles_set_attractors(p_particles, p_attractors);
681 }
particles_get_attractors(RID p_particles) const682 int VisualServerRaster::particles_get_attractors(RID p_particles) const {
683
684 return rasterizer->particles_get_attractors(p_particles);
685 }
686
particles_set_attractor_pos(RID p_particles,int p_attractor,const Vector3 & p_pos)687 void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos) {
688 VS_CHANGED;
689 rasterizer->particles_set_attractor_pos(p_particles, p_attractor, p_pos);
690 }
particles_get_attractor_pos(RID p_particles,int p_attractor) const691 Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles, int p_attractor) const {
692
693 return rasterizer->particles_get_attractor_pos(p_particles, p_attractor);
694 }
695
particles_set_attractor_strength(RID p_particles,int p_attractor,float p_force)696 void VisualServerRaster::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force) {
697 VS_CHANGED;
698 rasterizer->particles_set_attractor_strength(p_particles, p_attractor, p_force);
699 }
700
particles_get_attractor_strength(RID p_particles,int p_attractor) const701 float VisualServerRaster::particles_get_attractor_strength(RID p_particles, int p_attractor) const {
702
703 return rasterizer->particles_get_attractor_strength(p_particles, p_attractor);
704 }
705
particles_set_color_phase_color(RID p_particles,int p_phase,const Color & p_color)706 void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color) {
707 VS_CHANGED;
708 rasterizer->particles_set_color_phase_color(p_particles, p_phase, p_color);
709 }
particles_get_color_phase_color(RID p_particles,int p_phase) const710 Color VisualServerRaster::particles_get_color_phase_color(RID p_particles, int p_phase) const {
711
712 return rasterizer->particles_get_color_phase_color(p_particles, p_phase);
713 }
714
particles_set_material(RID p_particles,RID p_material,bool p_owned)715 void VisualServerRaster::particles_set_material(RID p_particles, RID p_material, bool p_owned) {
716 VS_CHANGED;
717 rasterizer->particles_set_material(p_particles, p_material, p_owned);
718 }
particles_get_material(RID p_particles) const719 RID VisualServerRaster::particles_get_material(RID p_particles) const {
720
721 return rasterizer->particles_get_material(p_particles);
722 }
723
particles_set_height_from_velocity(RID p_particles,bool p_enable)724 void VisualServerRaster::particles_set_height_from_velocity(RID p_particles, bool p_enable) {
725
726 VS_CHANGED;
727 rasterizer->particles_set_height_from_velocity(p_particles, p_enable);
728 }
729
particles_has_height_from_velocity(RID p_particles) const730 bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles) const {
731
732 return rasterizer->particles_has_height_from_velocity(p_particles);
733 }
734
particles_set_use_local_coordinates(RID p_particles,bool p_enable)735 void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
736
737 rasterizer->particles_set_use_local_coordinates(p_particles, p_enable);
738 }
739
particles_is_using_local_coordinates(RID p_particles) const740 bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles) const {
741
742 return rasterizer->particles_is_using_local_coordinates(p_particles);
743 }
744
745 /* Light API */
746
light_create(LightType p_type)747 RID VisualServerRaster::light_create(LightType p_type) {
748
749 return rasterizer->light_create(p_type);
750 }
light_get_type(RID p_light) const751 VisualServer::LightType VisualServerRaster::light_get_type(RID p_light) const {
752
753 return rasterizer->light_get_type(p_light);
754 }
755
light_set_color(RID p_light,LightColor p_type,const Color & p_color)756 void VisualServerRaster::light_set_color(RID p_light, LightColor p_type, const Color &p_color) {
757 VS_CHANGED;
758 rasterizer->light_set_color(p_light, p_type, p_color);
759 }
light_get_color(RID p_light,LightColor p_type) const760 Color VisualServerRaster::light_get_color(RID p_light, LightColor p_type) const {
761
762 return rasterizer->light_get_color(p_light, p_type);
763 }
764
light_set_shadow(RID p_light,bool p_enabled)765 void VisualServerRaster::light_set_shadow(RID p_light, bool p_enabled) {
766 VS_CHANGED;
767 rasterizer->light_set_shadow(p_light, p_enabled);
768 }
769
light_has_shadow(RID p_light) const770 bool VisualServerRaster::light_has_shadow(RID p_light) const {
771
772 return rasterizer->light_has_shadow(p_light);
773 }
774
light_set_volumetric(RID p_light,bool p_enabled)775 void VisualServerRaster::light_set_volumetric(RID p_light, bool p_enabled) {
776 VS_CHANGED;
777 rasterizer->light_set_volumetric(p_light, p_enabled);
778 }
779
light_is_volumetric(RID p_light) const780 bool VisualServerRaster::light_is_volumetric(RID p_light) const {
781
782 return rasterizer->light_is_volumetric(p_light);
783 }
784
light_set_projector(RID p_light,RID p_texture)785 void VisualServerRaster::light_set_projector(RID p_light, RID p_texture) {
786 VS_CHANGED;
787 rasterizer->light_set_projector(p_light, p_texture);
788 }
789
light_get_projector(RID p_light) const790 RID VisualServerRaster::light_get_projector(RID p_light) const {
791
792 return rasterizer->light_get_projector(p_light);
793 }
794
light_set_param(RID p_light,LightParam p_var,float p_value)795 void VisualServerRaster::light_set_param(RID p_light, LightParam p_var, float p_value) {
796 VS_CHANGED;
797 rasterizer->light_set_var(p_light, p_var, p_value);
798 _dependency_queue_update(p_light, true);
799 }
800
light_get_param(RID p_light,LightParam p_var) const801 float VisualServerRaster::light_get_param(RID p_light, LightParam p_var) const {
802
803 return rasterizer->light_get_var(p_light, p_var);
804 }
805
light_set_operator(RID p_light,LightOp p_op)806 void VisualServerRaster::light_set_operator(RID p_light, LightOp p_op) {
807 VS_CHANGED;
808 rasterizer->light_set_operator(p_light, p_op);
809 }
810
light_get_operator(RID p_light) const811 VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light) const {
812
813 return rasterizer->light_get_operator(p_light);
814 }
815
light_omni_set_shadow_mode(RID p_light,LightOmniShadowMode p_mode)816 void VisualServerRaster::light_omni_set_shadow_mode(RID p_light, LightOmniShadowMode p_mode) {
817 VS_CHANGED;
818 rasterizer->light_omni_set_shadow_mode(p_light, p_mode);
819 }
820
light_omni_get_shadow_mode(RID p_light) const821 VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light) const {
822
823 return rasterizer->light_omni_get_shadow_mode(p_light);
824 }
825
light_directional_set_shadow_mode(RID p_light,LightDirectionalShadowMode p_mode)826 void VisualServerRaster::light_directional_set_shadow_mode(RID p_light, LightDirectionalShadowMode p_mode) {
827 VS_CHANGED;
828 rasterizer->light_directional_set_shadow_mode(p_light, p_mode);
829 }
830
light_directional_get_shadow_mode(RID p_light) const831 VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light) const {
832
833 return rasterizer->light_directional_get_shadow_mode(p_light);
834 }
835
light_directional_set_shadow_param(RID p_light,LightDirectionalShadowParam p_param,float p_value)836 void VisualServerRaster::light_directional_set_shadow_param(RID p_light, LightDirectionalShadowParam p_param, float p_value) {
837 VS_CHANGED;
838 rasterizer->light_directional_set_shadow_param(p_light, p_param, p_value);
839 }
840
light_directional_get_shadow_param(RID p_light,LightDirectionalShadowParam p_param) const841 float VisualServerRaster::light_directional_get_shadow_param(RID p_light, LightDirectionalShadowParam p_param) const {
842
843 return rasterizer->light_directional_get_shadow_param(p_light, p_param);
844 }
845
skeleton_create()846 RID VisualServerRaster::skeleton_create() {
847
848 return rasterizer->skeleton_create();
849 }
850
skeleton_resize(RID p_skeleton,int p_bones)851 void VisualServerRaster::skeleton_resize(RID p_skeleton, int p_bones) {
852 VS_CHANGED;
853 rasterizer->skeleton_resize(p_skeleton, p_bones);
854 }
855
skeleton_get_bone_count(RID p_skeleton) const856 int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton) const {
857
858 return rasterizer->skeleton_get_bone_count(p_skeleton);
859 }
860
skeleton_bone_set_transform(RID p_skeleton,int p_bone,const Transform & p_transform)861 void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
862 VS_CHANGED;
863 rasterizer->skeleton_bone_set_transform(p_skeleton, p_bone, p_transform);
864
865 Map<RID, Set<Instance *> >::Element *E = skeleton_dependency_map.find(p_skeleton);
866
867 if (E) {
868 //detach skeletons
869 for (Set<Instance *>::Element *F = E->get().front(); F; F = F->next()) {
870
871 _instance_queue_update(F->get(), true);
872 }
873 }
874 }
875
skeleton_bone_get_transform(RID p_skeleton,int p_bone)876 Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton, int p_bone) {
877
878 return rasterizer->skeleton_bone_get_transform(p_skeleton, p_bone);
879 }
880
881 /* VISIBILITY API */
882
883 /* ROOM API */
884
room_create()885 RID VisualServerRaster::room_create() {
886
887 Room *room = memnew(Room);
888 ERR_FAIL_COND_V(!room, RID());
889 return room_owner.make_rid(room);
890 }
891
room_set_bounds(RID p_room,const BSP_Tree & p_bounds)892 void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree &p_bounds) {
893 VS_CHANGED;
894 Room *room = room_owner.get(p_room);
895 ERR_FAIL_COND(!room);
896 room->bounds = p_bounds;
897 _dependency_queue_update(p_room, true);
898 }
899
room_get_bounds(RID p_room) const900 BSP_Tree VisualServerRaster::room_get_bounds(RID p_room) const {
901
902 Room *room = room_owner.get(p_room);
903 ERR_FAIL_COND_V(!room, BSP_Tree());
904 return room->bounds;
905 }
906
907 /* PORTAL API */
908
portal_create()909 RID VisualServerRaster::portal_create() {
910 VS_CHANGED;
911 Portal *portal = memnew(Portal);
912 ERR_FAIL_COND_V(!portal, RID());
913 return portal_owner.make_rid(portal);
914 }
915
portal_set_shape(RID p_portal,const Vector<Point2> & p_shape)916 void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape) {
917 VS_CHANGED;
918 Portal *portal = portal_owner.get(p_portal);
919 ERR_FAIL_COND(!portal);
920 portal->shape = p_shape;
921
922 portal->bounds = Rect2();
923
924 for (int i = 0; i < p_shape.size(); i++) {
925
926 if (i == 0)
927 portal->bounds.pos = p_shape[i];
928 else
929 portal->bounds.expand_to(p_shape[i]);
930 }
931
932 _dependency_queue_update(p_portal, true);
933 }
934
portal_get_shape(RID p_portal) const935 Vector<Point2> VisualServerRaster::portal_get_shape(RID p_portal) const {
936
937 Portal *portal = portal_owner.get(p_portal);
938 ERR_FAIL_COND_V(!portal, Vector<Point2>());
939 return portal->shape;
940 }
941
portal_set_enabled(RID p_portal,bool p_enabled)942 void VisualServerRaster::portal_set_enabled(RID p_portal, bool p_enabled) {
943 VS_CHANGED;
944 Portal *portal = portal_owner.get(p_portal);
945 ERR_FAIL_COND(!portal);
946 portal->enabled = p_enabled;
947 }
948
portal_is_enabled(RID p_portal) const949 bool VisualServerRaster::portal_is_enabled(RID p_portal) const {
950
951 Portal *portal = portal_owner.get(p_portal);
952 ERR_FAIL_COND_V(!portal, false);
953 return portal->enabled;
954 }
portal_set_disable_distance(RID p_portal,float p_distance)955 void VisualServerRaster::portal_set_disable_distance(RID p_portal, float p_distance) {
956 VS_CHANGED;
957 Portal *portal = portal_owner.get(p_portal);
958 ERR_FAIL_COND(!portal);
959 portal->disable_distance = p_distance;
960 }
portal_get_disable_distance(RID p_portal) const961 float VisualServerRaster::portal_get_disable_distance(RID p_portal) const {
962
963 Portal *portal = portal_owner.get(p_portal);
964 ERR_FAIL_COND_V(!portal, -1);
965 return portal->disable_distance;
966 }
portal_set_disabled_color(RID p_portal,const Color & p_color)967 void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color &p_color) {
968 VS_CHANGED;
969 Portal *portal = portal_owner.get(p_portal);
970 ERR_FAIL_COND(!portal);
971 portal->disable_color = p_color;
972 }
portal_get_disabled_color(RID p_portal) const973 Color VisualServerRaster::portal_get_disabled_color(RID p_portal) const {
974
975 Portal *portal = portal_owner.get(p_portal);
976 ERR_FAIL_COND_V(!portal, Color());
977 return portal->disable_color;
978 }
979
portal_set_connect_range(RID p_portal,float p_range)980 void VisualServerRaster::portal_set_connect_range(RID p_portal, float p_range) {
981 VS_CHANGED;
982 Portal *portal = portal_owner.get(p_portal);
983 ERR_FAIL_COND(!portal);
984 portal->connect_range = p_range;
985 _dependency_queue_update(p_portal, true);
986 }
987
portal_get_connect_range(RID p_portal) const988 float VisualServerRaster::portal_get_connect_range(RID p_portal) const {
989
990 Portal *portal = portal_owner.get(p_portal);
991 ERR_FAIL_COND_V(!portal, 0);
992 return portal->connect_range;
993 }
994
baked_light_create()995 RID VisualServerRaster::baked_light_create() {
996
997 BakedLight *baked_light = memnew(BakedLight);
998 ERR_FAIL_COND_V(!baked_light, RID());
999 baked_light->data.mode = BAKED_LIGHT_OCTREE;
1000
1001 baked_light->data.octree_lattice_size = 0;
1002 baked_light->data.octree_lattice_divide = 0;
1003 baked_light->data.octree_steps = 1;
1004 baked_light->data.lightmap_multiplier = 1.0;
1005 baked_light->data.realtime_color_enabled = false;
1006 baked_light->data.realtime_color = Color(1.0, 1.0, 1.0);
1007 baked_light->data.realtime_energy = 1.0;
1008
1009 return baked_light_owner.make_rid(baked_light);
1010 }
1011
baked_light_set_mode(RID p_baked_light,BakedLightMode p_mode)1012 void VisualServerRaster::baked_light_set_mode(RID p_baked_light, BakedLightMode p_mode) {
1013
1014 VS_CHANGED;
1015 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1016 ERR_FAIL_COND(!baked_light);
1017 baked_light->data.mode = p_mode;
1018 baked_light->data.color_multiplier = 1.0;
1019 _dependency_queue_update(p_baked_light, true);
1020 }
1021
baked_light_get_mode(RID p_baked_light) const1022 VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light) const {
1023
1024 const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1025 ERR_FAIL_COND_V(!baked_light, BAKED_LIGHT_OCTREE);
1026 return baked_light->data.mode;
1027 }
1028
baked_light_set_lightmap_multiplier(RID p_baked_light,float p_multiplier)1029 void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light, float p_multiplier) {
1030
1031 VS_CHANGED;
1032 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1033 ERR_FAIL_COND(!baked_light);
1034
1035 baked_light->data.lightmap_multiplier = p_multiplier;
1036 }
1037
baked_light_get_lightmap_multiplier(RID p_baked_light) const1038 float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light) const {
1039
1040 const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1041 ERR_FAIL_COND_V(!baked_light, 0);
1042
1043 return baked_light->data.lightmap_multiplier;
1044 }
1045
baked_light_set_octree(RID p_baked_light,const DVector<uint8_t> p_octree)1046 void VisualServerRaster::baked_light_set_octree(RID p_baked_light, const DVector<uint8_t> p_octree) {
1047
1048 VS_CHANGED;
1049 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1050 ERR_FAIL_COND(!baked_light);
1051
1052 if (p_octree.size() == 0) {
1053 if (baked_light->data.octree_texture.is_valid())
1054 rasterizer->free(baked_light->data.octree_texture);
1055 baked_light->data.octree_texture = RID();
1056 baked_light->octree_aabb = AABB();
1057 baked_light->octree_tex_size = Size2();
1058 } else {
1059
1060 int tex_w;
1061 int tex_h;
1062 int light_tex_w;
1063 int light_tex_h;
1064 bool is16;
1065 bool has_light_tex = false;
1066 {
1067
1068 DVector<uint8_t>::Read r = p_octree.read();
1069 tex_w = decode_uint32(&r[0]);
1070 tex_h = decode_uint32(&r[4]);
1071 print_line("TEX W: " + itos(tex_w) + " TEX H:" + itos(tex_h) + " LEN: " + itos(p_octree.size()));
1072 is16 = decode_uint32(&r[8]);
1073 baked_light->data.octree_lattice_size = decode_float(&r[12]);
1074 baked_light->data.octree_lattice_divide = tex_w / 4.0;
1075 print_line("LATTICE SIZE: " + rtos(baked_light->data.octree_lattice_size));
1076 print_line("LATTICE DIVIDE: " + rtos(baked_light->data.octree_lattice_divide));
1077 baked_light->data.octree_steps = decode_uint32(&r[16]);
1078 baked_light->data.octree_tex_pixel_size.x = 1.0 / tex_w;
1079 baked_light->data.octree_tex_pixel_size.y = 1.0 / tex_h;
1080
1081 baked_light->data.texture_multiplier = decode_uint32(&r[20]);
1082 light_tex_w = decode_uint16(&r[24]);
1083 light_tex_h = decode_uint16(&r[26]);
1084 print_line("ltexw " + itos(light_tex_w));
1085 print_line("ltexh " + itos(light_tex_h));
1086
1087 if (light_tex_w > 0 && light_tex_h > 0) {
1088 baked_light->data.light_tex_pixel_size.x = 1.0 / light_tex_w;
1089 baked_light->data.light_tex_pixel_size.y = 1.0 / light_tex_h;
1090 has_light_tex = true;
1091 } else {
1092 baked_light->data.light_tex_pixel_size = baked_light->data.octree_tex_pixel_size;
1093 }
1094
1095 baked_light->octree_aabb.pos.x = decode_float(&r[32]);
1096 baked_light->octree_aabb.pos.y = decode_float(&r[36]);
1097 baked_light->octree_aabb.pos.z = decode_float(&r[40]);
1098 baked_light->octree_aabb.size.x = decode_float(&r[44]);
1099 baked_light->octree_aabb.size.y = decode_float(&r[48]);
1100 baked_light->octree_aabb.size.z = decode_float(&r[52]);
1101 }
1102
1103 if (baked_light->data.octree_texture.is_valid()) {
1104 if (tex_w != baked_light->octree_tex_size.x || tex_h != baked_light->octree_tex_size.y) {
1105
1106 rasterizer->free(baked_light->data.octree_texture);
1107 baked_light->data.octree_texture = RID();
1108 baked_light->octree_tex_size.x = 0;
1109 baked_light->octree_tex_size.y = 0;
1110 }
1111 }
1112
1113 if (baked_light->data.light_texture.is_valid()) {
1114 if (!has_light_tex || light_tex_w != baked_light->light_tex_size.x || light_tex_h != baked_light->light_tex_size.y) {
1115 rasterizer->free(baked_light->data.light_texture);
1116 baked_light->data.light_texture = RID();
1117 baked_light->light_tex_size.x = 0;
1118 baked_light->light_tex_size.y = 0;
1119 }
1120 }
1121
1122 if (!baked_light->data.octree_texture.is_valid()) {
1123 baked_light->data.octree_texture = rasterizer->texture_create();
1124 rasterizer->texture_allocate(baked_light->data.octree_texture, tex_w, tex_h, Image::FORMAT_RGBA, TEXTURE_FLAG_FILTER);
1125 baked_light->octree_tex_size.x = tex_w;
1126 baked_light->octree_tex_size.y = tex_h;
1127 }
1128
1129 if (!baked_light->data.light_texture.is_valid() && has_light_tex) {
1130 baked_light->data.light_texture = rasterizer->texture_create();
1131 rasterizer->texture_allocate(baked_light->data.light_texture, light_tex_w, light_tex_h, Image::FORMAT_RGBA, TEXTURE_FLAG_FILTER);
1132 baked_light->light_tex_size.x = light_tex_w;
1133 baked_light->light_tex_size.y = light_tex_h;
1134 }
1135
1136 Image img(tex_w, tex_h, 0, Image::FORMAT_RGBA, p_octree);
1137 rasterizer->texture_set_data(baked_light->data.octree_texture, img);
1138 }
1139
1140 _dependency_queue_update(p_baked_light, true);
1141 }
1142
baked_light_get_octree(RID p_baked_light) const1143 DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light) const {
1144
1145 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1146 ERR_FAIL_COND_V(!baked_light, DVector<uint8_t>());
1147
1148 if (rasterizer->is_texture(baked_light->data.octree_texture)) {
1149
1150 Image img = rasterizer->texture_get_data(baked_light->data.octree_texture);
1151 return img.get_data();
1152 } else {
1153 return DVector<uint8_t>();
1154 }
1155 }
1156
baked_light_set_light(RID p_baked_light,const DVector<uint8_t> p_light)1157 void VisualServerRaster::baked_light_set_light(RID p_baked_light, const DVector<uint8_t> p_light) {
1158
1159 VS_CHANGED;
1160 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1161 ERR_FAIL_COND(!baked_light);
1162 ERR_FAIL_COND(p_light.size() == 0);
1163
1164 int tex_w = baked_light->light_tex_size.x;
1165 int tex_h = baked_light->light_tex_size.y;
1166
1167 ERR_FAIL_COND(tex_w == 0 && tex_h == 0);
1168 ERR_FAIL_COND(!baked_light->data.light_texture.is_valid());
1169
1170 print_line("w: " + itos(tex_w) + " h: " + itos(tex_h) + " lightsize: " + itos(p_light.size()));
1171
1172 Image img(tex_w, tex_h, 0, Image::FORMAT_RGBA, p_light);
1173 rasterizer->texture_set_data(baked_light->data.light_texture, img);
1174 }
1175
baked_light_get_light(RID p_baked_light) const1176 DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light) const {
1177
1178 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1179 ERR_FAIL_COND_V(!baked_light, DVector<uint8_t>());
1180
1181 if (rasterizer->is_texture(baked_light->data.light_texture)) {
1182
1183 Image img = rasterizer->texture_get_data(baked_light->data.light_texture);
1184 return img.get_data();
1185 } else {
1186 return DVector<uint8_t>();
1187 }
1188 }
1189
baked_light_set_sampler_octree(RID p_baked_light,const DVector<int> & p_sampler)1190 void VisualServerRaster::baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler) {
1191
1192 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1193 ERR_FAIL_COND(!baked_light);
1194
1195 baked_light->sampler = p_sampler;
1196 }
1197
baked_light_get_sampler_octree(RID p_baked_light) const1198 DVector<int> VisualServerRaster::baked_light_get_sampler_octree(RID p_baked_light) const {
1199
1200 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1201 ERR_FAIL_COND_V(!baked_light, DVector<int>());
1202
1203 return baked_light->sampler;
1204 }
1205
baked_light_add_lightmap(RID p_baked_light,const RID p_texture,int p_id)1206 void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light, const RID p_texture, int p_id) {
1207
1208 VS_CHANGED;
1209 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1210 ERR_FAIL_COND(!baked_light);
1211 baked_light->data.lightmaps.insert(p_id, p_texture);
1212 }
baked_light_clear_lightmaps(RID p_baked_light)1213 void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light) {
1214
1215 VS_CHANGED;
1216 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1217 ERR_FAIL_COND(!baked_light);
1218 baked_light->data.lightmaps.clear();
1219 }
1220
baked_light_set_realtime_color_enabled(RID p_baked_light,const bool p_enabled)1221 void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled) {
1222
1223 VS_CHANGED;
1224 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1225 ERR_FAIL_COND(!baked_light);
1226
1227 baked_light->data.realtime_color_enabled = p_enabled;
1228 }
1229
baked_light_get_realtime_color_enabled(RID p_baked_light) const1230 bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light) const {
1231
1232 const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1233 ERR_FAIL_COND_V(!baked_light, false);
1234
1235 return baked_light->data.realtime_color_enabled;
1236 }
1237
baked_light_set_realtime_color(RID p_baked_light,const Color & p_color)1238 void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color &p_color) {
1239
1240 VS_CHANGED;
1241 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1242 ERR_FAIL_COND(!baked_light);
1243
1244 baked_light->data.realtime_color = p_color;
1245 }
1246
baked_light_get_realtime_color(RID p_baked_light) const1247 Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light) const {
1248
1249 const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1250 ERR_FAIL_COND_V(!baked_light, Color(1.0, 1.0, 1.0));
1251
1252 return baked_light->data.realtime_color;
1253 }
1254
baked_light_set_realtime_energy(RID p_baked_light,const float p_energy)1255 void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, const float p_energy) {
1256
1257 VS_CHANGED;
1258 BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1259 ERR_FAIL_COND(!baked_light);
1260
1261 baked_light->data.realtime_energy = p_energy;
1262 }
1263
baked_light_get_realtime_energy(RID p_baked_light) const1264 float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light) const {
1265
1266 const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
1267 ERR_FAIL_COND_V(!baked_light, 1.0f);
1268
1269 return baked_light->data.realtime_energy;
1270 }
1271
1272 /* BAKED LIGHT SAMPLER */
1273
baked_light_sampler_create()1274 RID VisualServerRaster::baked_light_sampler_create() {
1275
1276 BakedLightSampler *blsamp = memnew(BakedLightSampler);
1277 RID rid = baked_light_sampler_owner.make_rid(blsamp);
1278 _update_baked_light_sampler_dp_cache(blsamp);
1279 return rid;
1280 }
1281
baked_light_sampler_set_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param,float p_value)1282 void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param, float p_value) {
1283
1284 VS_CHANGED;
1285 BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
1286 ERR_FAIL_COND(!blsamp);
1287 ERR_FAIL_INDEX(p_param, BAKED_LIGHT_SAMPLER_MAX);
1288 blsamp->params[p_param] = p_value;
1289 _dependency_queue_update(p_baked_light_sampler, true);
1290 }
1291
baked_light_sampler_get_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param) const1292 float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param) const {
1293
1294 BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
1295 ERR_FAIL_COND_V(!blsamp, 0);
1296 ERR_FAIL_INDEX_V(p_param, BAKED_LIGHT_SAMPLER_MAX, 0);
1297 return blsamp->params[p_param];
1298 }
1299
_update_baked_light_sampler_dp_cache(BakedLightSampler * blsamp)1300 void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler *blsamp) {
1301
1302 int res = blsamp->resolution;
1303 blsamp->dp_cache.resize(res * res * 2);
1304 Vector3 *dp_normals = blsamp->dp_cache.ptr();
1305
1306 for (int p = 0; p < 2; p++) {
1307 float sign = p == 0 ? 1 : -1;
1308 int ofs = res * res * p;
1309 for (int i = 0; i < res; i++) {
1310 for (int j = 0; j < res; j++) {
1311
1312 Vector2 v(
1313 (i / float(res)) * 2.0 - 1.0,
1314 (j / float(res)) * 2.0 - 1.0);
1315
1316 float l = v.length();
1317 if (l > 1.0) {
1318 v /= l;
1319 l = 1.0; //clamp to avoid imaginary
1320 }
1321 v *= (2 * l) / (l * l + 1); //inverse of the dual paraboloid function
1322 Vector3 n = Vector3(v.x, v.y, sign * sqrtf(MAX(1 - v.dot(v), 0))); //reconstruction of z
1323 n.y *= sign;
1324 dp_normals[j * res + i + ofs] = n;
1325 }
1326 }
1327 }
1328 }
1329
baked_light_sampler_set_resolution(RID p_baked_light_sampler,int p_resolution)1330 void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler, int p_resolution) {
1331
1332 ERR_FAIL_COND(p_resolution < 4 || p_resolution > 64);
1333 VS_CHANGED;
1334 BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
1335 ERR_FAIL_COND(!blsamp);
1336 blsamp->resolution = p_resolution;
1337 _update_baked_light_sampler_dp_cache(blsamp);
1338 }
baked_light_sampler_get_resolution(RID p_baked_light_sampler) const1339 int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler) const {
1340
1341 BakedLightSampler *blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
1342 ERR_FAIL_COND_V(!blsamp, 0);
1343 return blsamp->resolution;
1344 }
1345
1346 /* CAMERA API */
1347
camera_create()1348 RID VisualServerRaster::camera_create() {
1349
1350 Camera *camera = memnew(Camera);
1351 return camera_owner.make_rid(camera);
1352 }
1353
camera_set_perspective(RID p_camera,float p_fovy_degrees,float p_z_near,float p_z_far)1354 void VisualServerRaster::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
1355 VS_CHANGED
1356 Camera *camera = camera_owner.get(p_camera);
1357 ERR_FAIL_COND(!camera);
1358 camera->type = Camera::PERSPECTIVE;
1359 camera->fov = p_fovy_degrees;
1360 camera->znear = p_z_near;
1361 camera->zfar = p_z_far;
1362 }
1363
camera_set_orthogonal(RID p_camera,float p_size,float p_z_near,float p_z_far)1364 void VisualServerRaster::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) {
1365 VS_CHANGED;
1366 Camera *camera = camera_owner.get(p_camera);
1367 ERR_FAIL_COND(!camera);
1368 camera->type = Camera::ORTHOGONAL;
1369 camera->size = p_size;
1370 camera->znear = p_z_near;
1371 camera->zfar = p_z_far;
1372 }
1373
camera_set_transform(RID p_camera,const Transform & p_transform)1374 void VisualServerRaster::camera_set_transform(RID p_camera, const Transform &p_transform) {
1375 VS_CHANGED;
1376 Camera *camera = camera_owner.get(p_camera);
1377 ERR_FAIL_COND(!camera);
1378 camera->transform = p_transform.orthonormalized();
1379 }
1380
camera_set_visible_layers(RID p_camera,uint32_t p_layers)1381 void VisualServerRaster::camera_set_visible_layers(RID p_camera, uint32_t p_layers) {
1382
1383 VS_CHANGED;
1384 Camera *camera = camera_owner.get(p_camera);
1385 ERR_FAIL_COND(!camera);
1386
1387 camera->visible_layers = p_layers;
1388 }
1389
camera_get_visible_layers(RID p_camera) const1390 uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera) const {
1391
1392 const Camera *camera = camera_owner.get(p_camera);
1393 ERR_FAIL_COND_V(!camera, 0);
1394
1395 return camera->visible_layers;
1396 }
1397
camera_set_environment(RID p_camera,RID p_env)1398 void VisualServerRaster::camera_set_environment(RID p_camera, RID p_env) {
1399
1400 Camera *camera = camera_owner.get(p_camera);
1401 ERR_FAIL_COND(!camera);
1402 camera->env = p_env;
1403 }
1404
camera_get_environment(RID p_camera) const1405 RID VisualServerRaster::camera_get_environment(RID p_camera) const {
1406
1407 const Camera *camera = camera_owner.get(p_camera);
1408 ERR_FAIL_COND_V(!camera, RID());
1409 return camera->env;
1410 }
1411
camera_set_use_vertical_aspect(RID p_camera,bool p_enable)1412 void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
1413
1414 Camera *camera = camera_owner.get(p_camera);
1415 ERR_FAIL_COND(!camera);
1416 camera->vaspect = p_enable;
1417 }
camera_is_using_vertical_aspect(RID p_camera,bool p_enable) const1418 bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera, bool p_enable) const {
1419
1420 const Camera *camera = camera_owner.get(p_camera);
1421 ERR_FAIL_COND_V(!camera, false);
1422 return camera->vaspect;
1423 }
1424
1425 /* VIEWPORT API */
1426
viewport_create()1427 RID VisualServerRaster::viewport_create() {
1428
1429 Viewport *viewport = memnew(Viewport);
1430 RID rid = viewport_owner.make_rid(viewport);
1431 ERR_FAIL_COND_V(!rid.is_valid(), rid);
1432
1433 viewport->self = rid;
1434 viewport->hide_scenario = false;
1435 viewport->hide_canvas = false;
1436 viewport->viewport_data = rasterizer->viewport_data_create();
1437
1438 return rid;
1439 }
1440
viewport_attach_to_screen(RID p_viewport,int p_screen)1441 void VisualServerRaster::viewport_attach_to_screen(RID p_viewport, int p_screen) {
1442
1443 VS_CHANGED;
1444 Viewport *viewport = viewport_owner.get(p_viewport);
1445 ERR_FAIL_COND(!viewport);
1446
1447 screen_viewports[p_viewport] = p_screen;
1448 }
1449
viewport_detach(RID p_viewport)1450 void VisualServerRaster::viewport_detach(RID p_viewport) {
1451
1452 VS_CHANGED;
1453 Viewport *viewport = viewport_owner.get(p_viewport);
1454 ERR_FAIL_COND(!viewport);
1455
1456 ERR_FAIL_COND(!screen_viewports.has(p_viewport));
1457 screen_viewports.erase(p_viewport);
1458 }
1459
viewport_set_as_render_target(RID p_viewport,bool p_enable)1460 void VisualServerRaster::viewport_set_as_render_target(RID p_viewport, bool p_enable) {
1461
1462 VS_CHANGED;
1463 Viewport *viewport = viewport_owner.get(p_viewport);
1464 ERR_FAIL_COND(!viewport);
1465
1466 if (viewport->render_target.is_valid() == p_enable)
1467 return;
1468 if (!p_enable) {
1469
1470 rasterizer->free(viewport->render_target);
1471 viewport->render_target = RID();
1472 viewport->render_target_texture = RID();
1473 if (viewport->update_list.in_list())
1474 viewport_update_list.remove(&viewport->update_list);
1475
1476 } else {
1477
1478 viewport->render_target = rasterizer->render_target_create();
1479 rasterizer->render_target_set_size(viewport->render_target, viewport->rect.width, viewport->rect.height);
1480 viewport->render_target_texture = rasterizer->render_target_get_texture(viewport->render_target);
1481 if (viewport->render_target_update_mode != RENDER_TARGET_UPDATE_DISABLED)
1482 viewport_update_list.add(&viewport->update_list);
1483 }
1484 }
1485
viewport_set_render_target_update_mode(RID p_viewport,RenderTargetUpdateMode p_mode)1486 void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport, RenderTargetUpdateMode p_mode) {
1487
1488 VS_CHANGED;
1489 Viewport *viewport = viewport_owner.get(p_viewport);
1490 ERR_FAIL_COND(!viewport);
1491
1492 if (viewport->render_target.is_valid() && viewport->update_list.in_list())
1493 viewport_update_list.remove(&viewport->update_list);
1494
1495 viewport->render_target_update_mode = p_mode;
1496
1497 if (viewport->render_target.is_valid() && viewport->render_target_update_mode != RENDER_TARGET_UPDATE_DISABLED)
1498 viewport_update_list.add(&viewport->update_list);
1499 }
viewport_get_render_target_update_mode(RID p_viewport) const1500 VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport) const {
1501
1502 const Viewport *viewport = viewport_owner.get(p_viewport);
1503 ERR_FAIL_COND_V(!viewport, RENDER_TARGET_UPDATE_DISABLED);
1504
1505 return viewport->render_target_update_mode;
1506 }
viewport_get_render_target_texture(RID p_viewport) const1507 RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport) const {
1508
1509 Viewport *viewport = viewport_owner.get(p_viewport);
1510 ERR_FAIL_COND_V(!viewport, RID());
1511
1512 return viewport->render_target_texture;
1513 }
1514
viewport_set_render_target_vflip(RID p_viewport,bool p_enable)1515 void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport, bool p_enable) {
1516
1517 Viewport *viewport = viewport_owner.get(p_viewport);
1518 ERR_FAIL_COND(!viewport);
1519
1520 viewport->render_target_vflip = p_enable;
1521 }
1522
viewport_set_render_target_clear_on_new_frame(RID p_viewport,bool p_enable)1523 void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport, bool p_enable) {
1524
1525 Viewport *viewport = viewport_owner.get(p_viewport);
1526 ERR_FAIL_COND(!viewport);
1527
1528 viewport->render_target_clear_on_new_frame = p_enable;
1529 }
1530
viewport_set_render_target_to_screen_rect(RID p_viewport,const Rect2 & p_rect)1531 void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport, const Rect2 &p_rect) {
1532
1533 Viewport *viewport = viewport_owner.get(p_viewport);
1534 ERR_FAIL_COND(!viewport);
1535
1536 viewport->rt_to_screen_rect = p_rect;
1537 }
1538
viewport_get_render_target_vflip(RID p_viewport) const1539 bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport) const {
1540
1541 const Viewport *viewport = viewport_owner.get(p_viewport);
1542 ERR_FAIL_COND_V(!viewport, false);
1543
1544 return viewport->render_target_vflip;
1545 }
1546
viewport_get_render_target_clear_on_new_frame(RID p_viewport) const1547 bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport) const {
1548
1549 const Viewport *viewport = viewport_owner.get(p_viewport);
1550 ERR_FAIL_COND_V(!viewport, false);
1551
1552 return viewport->render_target_clear_on_new_frame;
1553 }
1554
viewport_render_target_clear(RID p_viewport)1555 void VisualServerRaster::viewport_render_target_clear(RID p_viewport) {
1556
1557 Viewport *viewport = viewport_owner.get(p_viewport);
1558 ERR_FAIL_COND(!viewport);
1559
1560 viewport->render_target_clear = true;
1561 }
1562
viewport_queue_screen_capture(RID p_viewport)1563 void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport) {
1564
1565 VS_CHANGED;
1566 Viewport *viewport = viewport_owner.get(p_viewport);
1567 ERR_FAIL_COND(!viewport);
1568 viewport->queue_capture = true;
1569 }
1570
viewport_get_screen_capture(RID p_viewport) const1571 Image VisualServerRaster::viewport_get_screen_capture(RID p_viewport) const {
1572
1573 Viewport *viewport = (Viewport *)viewport_owner.get(p_viewport);
1574 ERR_FAIL_COND_V(!viewport, Image());
1575
1576 Image ret = viewport->capture;
1577 viewport->capture = Image();
1578 return ret;
1579 }
1580
viewport_set_rect(RID p_viewport,const ViewportRect & p_rect)1581 void VisualServerRaster::viewport_set_rect(RID p_viewport, const ViewportRect &p_rect) {
1582 VS_CHANGED;
1583 Viewport *viewport = NULL;
1584
1585 viewport = viewport_owner.get(p_viewport);
1586
1587 ERR_FAIL_COND(!viewport);
1588
1589 viewport->rect = p_rect;
1590 if (viewport->render_target.is_valid()) {
1591 rasterizer->render_target_set_size(viewport->render_target, viewport->rect.width, viewport->rect.height);
1592 }
1593 }
1594
viewport_get_rect(RID p_viewport) const1595 VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport) const {
1596
1597 const Viewport *viewport = NULL;
1598
1599 viewport = viewport_owner.get(p_viewport);
1600 ERR_FAIL_COND_V(!viewport, ViewportRect());
1601
1602 return viewport->rect;
1603 }
1604
viewport_set_hide_scenario(RID p_viewport,bool p_hide)1605 void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport, bool p_hide) {
1606
1607 VS_CHANGED;
1608
1609 Viewport *viewport = NULL;
1610
1611 viewport = viewport_owner.get(p_viewport);
1612 ERR_FAIL_COND(!viewport);
1613
1614 viewport->hide_scenario = p_hide;
1615 }
1616
viewport_set_hide_canvas(RID p_viewport,bool p_hide)1617 void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport, bool p_hide) {
1618
1619 VS_CHANGED;
1620
1621 Viewport *viewport = NULL;
1622
1623 viewport = viewport_owner.get(p_viewport);
1624 ERR_FAIL_COND(!viewport);
1625
1626 viewport->hide_canvas = p_hide;
1627 }
1628
viewport_set_disable_environment(RID p_viewport,bool p_disable)1629 void VisualServerRaster::viewport_set_disable_environment(RID p_viewport, bool p_disable) {
1630
1631 VS_CHANGED;
1632
1633 Viewport *viewport = NULL;
1634 viewport = viewport_owner.get(p_viewport);
1635 ERR_FAIL_COND(!viewport);
1636 viewport->disable_environment = p_disable;
1637 }
1638
viewport_attach_camera(RID p_viewport,RID p_camera)1639 void VisualServerRaster::viewport_attach_camera(RID p_viewport, RID p_camera) {
1640 VS_CHANGED;
1641
1642 Viewport *viewport = NULL;
1643 viewport = viewport_owner.get(p_viewport);
1644 ERR_FAIL_COND(!viewport);
1645
1646 if (p_camera.is_valid()) {
1647
1648 ERR_FAIL_COND(!camera_owner.owns(p_camera));
1649 // a camera
1650 viewport->camera = p_camera;
1651 } else {
1652 viewport->camera = RID();
1653 }
1654 }
1655
viewport_set_scenario(RID p_viewport,RID p_scenario)1656 void VisualServerRaster::viewport_set_scenario(RID p_viewport, RID p_scenario) {
1657
1658 VS_CHANGED;
1659
1660 Viewport *viewport = NULL;
1661 viewport = viewport_owner.get(p_viewport);
1662 ERR_FAIL_COND(!viewport);
1663
1664 if (p_scenario.is_valid()) {
1665
1666 ERR_FAIL_COND(!scenario_owner.owns(p_scenario));
1667 // a camera
1668 viewport->scenario = p_scenario;
1669 } else {
1670 viewport->scenario = RID();
1671 }
1672 }
1673
viewport_get_attached_camera(RID p_viewport) const1674 RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport) const {
1675
1676 const Viewport *viewport = NULL;
1677
1678 viewport = viewport_owner.get(p_viewport);
1679 ERR_FAIL_COND_V(!viewport, RID());
1680
1681 return viewport->camera;
1682 }
1683
viewport_attach_canvas(RID p_viewport,RID p_canvas)1684 void VisualServerRaster::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
1685 VS_CHANGED;
1686 Viewport *viewport = NULL;
1687
1688 viewport = viewport_owner.get(p_viewport);
1689 ERR_FAIL_COND(!viewport);
1690
1691 Canvas *canvas = canvas_owner.get(p_canvas);
1692 ERR_FAIL_COND(!canvas);
1693
1694 ERR_EXPLAIN("Canvas already attached.");
1695 ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
1696
1697 Viewport::CanvasData cd;
1698 cd.canvas = canvas;
1699 cd.layer = 0;
1700
1701 viewport->canvas_map[p_canvas] = cd;
1702 canvas->viewports.insert(p_viewport);
1703 }
1704
viewport_set_canvas_transform(RID p_viewport,RID p_canvas,const Matrix32 & p_transform)1705 void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Matrix32 &p_transform) {
1706
1707 VS_CHANGED;
1708 Viewport *viewport = NULL;
1709 viewport = viewport_owner.get(p_viewport);
1710 ERR_FAIL_COND(!viewport);
1711
1712 Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
1713 if (!E) {
1714 ERR_EXPLAIN("Viewport does not contain the canvas");
1715 ERR_FAIL_COND(!E);
1716 }
1717
1718 E->get().transform = p_transform;
1719 }
1720
viewport_get_canvas_transform(RID p_viewport,RID p_canvas) const1721 Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport, RID p_canvas) const {
1722
1723 Viewport *viewport = NULL;
1724 viewport = viewport_owner.get(p_viewport);
1725 ERR_FAIL_COND_V(!viewport, Matrix32());
1726
1727 Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
1728 if (!E) {
1729 ERR_EXPLAIN("Viewport does not contain the canvas");
1730 ERR_FAIL_COND_V(!E, Matrix32());
1731 }
1732
1733 return E->get().transform;
1734 }
1735
viewport_set_global_canvas_transform(RID p_viewport,const Matrix32 & p_transform)1736 void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport, const Matrix32 &p_transform) {
1737
1738 VS_CHANGED
1739 Viewport *viewport = NULL;
1740 viewport = viewport_owner.get(p_viewport);
1741 ERR_FAIL_COND(!viewport);
1742
1743 viewport->global_transform = p_transform;
1744 }
1745
viewport_get_global_canvas_transform(RID p_viewport) const1746 Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport) const {
1747
1748 Viewport *viewport = NULL;
1749 viewport = viewport_owner.get(p_viewport);
1750 ERR_FAIL_COND_V(!viewport, Matrix32());
1751 return viewport->global_transform;
1752 }
1753
viewport_remove_canvas(RID p_viewport,RID p_canvas)1754 void VisualServerRaster::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
1755
1756 VS_CHANGED;
1757 Viewport *viewport = NULL;
1758
1759 viewport = viewport_owner.get(p_viewport);
1760 ERR_FAIL_COND(!viewport);
1761
1762 Canvas *canvas = canvas_owner.get(p_canvas);
1763 ERR_FAIL_COND(!canvas);
1764
1765 Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
1766 if (!E) {
1767 ERR_EXPLAIN("Viewport does not contain the canvas");
1768 ERR_FAIL_COND(!E);
1769 }
1770
1771 canvas->viewports.erase(p_viewport);
1772 viewport->canvas_map.erase(E);
1773 }
1774
viewport_set_canvas_layer(RID p_viewport,RID p_canvas,int p_layer)1775 void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport, RID p_canvas, int p_layer) {
1776
1777 VS_CHANGED;
1778 Viewport *viewport = NULL;
1779
1780 viewport = viewport_owner.get(p_viewport);
1781 ERR_FAIL_COND(!viewport);
1782
1783 Map<RID, Viewport::CanvasData>::Element *E = viewport->canvas_map.find(p_canvas);
1784 if (!E) {
1785 ERR_EXPLAIN("Viewport does not contain the canvas");
1786 ERR_FAIL_COND(!E);
1787 }
1788
1789 E->get().layer = p_layer;
1790 }
1791
viewport_set_transparent_background(RID p_viewport,bool p_enabled)1792 void VisualServerRaster::viewport_set_transparent_background(RID p_viewport, bool p_enabled) {
1793
1794 VS_CHANGED;
1795 Viewport *viewport = viewport_owner.get(p_viewport);
1796 ERR_FAIL_COND(!viewport);
1797
1798 viewport->transparent_bg = p_enabled;
1799 }
1800
viewport_has_transparent_background(RID p_viewport) const1801 bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport) const {
1802
1803 Viewport *viewport = viewport_owner.get(p_viewport);
1804 ERR_FAIL_COND_V(!viewport, false);
1805
1806 return viewport->transparent_bg;
1807 }
1808
viewport_get_scenario(RID p_viewport) const1809 RID VisualServerRaster::viewport_get_scenario(RID p_viewport) const {
1810
1811 const Viewport *viewport = NULL;
1812
1813 viewport = viewport_owner.get(p_viewport);
1814 ERR_FAIL_COND_V(!viewport, RID());
1815
1816 return viewport->scenario;
1817 }
1818
environment_create()1819 RID VisualServerRaster::environment_create() {
1820
1821 return rasterizer->environment_create();
1822 }
1823
environment_set_background(RID p_env,EnvironmentBG p_bg)1824 void VisualServerRaster::environment_set_background(RID p_env, EnvironmentBG p_bg) {
1825
1826 rasterizer->environment_set_background(p_env, p_bg);
1827 }
environment_get_background(RID p_env) const1828 VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env) const {
1829
1830 return rasterizer->environment_get_background(p_env);
1831 }
1832
environment_set_background_param(RID p_env,EnvironmentBGParam p_param,const Variant & p_value)1833 void VisualServerRaster::environment_set_background_param(RID p_env, EnvironmentBGParam p_param, const Variant &p_value) {
1834
1835 rasterizer->environment_set_background_param(p_env, p_param, p_value);
1836 }
environment_get_background_param(RID p_env,EnvironmentBGParam p_param) const1837 Variant VisualServerRaster::environment_get_background_param(RID p_env, EnvironmentBGParam p_param) const {
1838
1839 return rasterizer->environment_get_background_param(p_env, p_param);
1840 }
1841
environment_set_enable_fx(RID p_env,EnvironmentFx p_effect,bool p_enabled)1842 void VisualServerRaster::environment_set_enable_fx(RID p_env, EnvironmentFx p_effect, bool p_enabled) {
1843
1844 rasterizer->environment_set_enable_fx(p_env, p_effect, p_enabled);
1845 }
environment_is_fx_enabled(RID p_env,EnvironmentFx p_effect) const1846 bool VisualServerRaster::environment_is_fx_enabled(RID p_env, EnvironmentFx p_effect) const {
1847
1848 return rasterizer->environment_is_fx_enabled(p_env, p_effect);
1849 }
1850
environment_fx_set_param(RID p_env,EnvironmentFxParam p_param,const Variant & p_value)1851 void VisualServerRaster::environment_fx_set_param(RID p_env, EnvironmentFxParam p_param, const Variant &p_value) {
1852
1853 rasterizer->environment_fx_set_param(p_env, p_param, p_value);
1854 }
environment_fx_get_param(RID p_env,EnvironmentFxParam p_param) const1855 Variant VisualServerRaster::environment_fx_get_param(RID p_env, EnvironmentFxParam p_param) const {
1856
1857 return environment_fx_get_param(p_env, p_param);
1858 }
1859
1860 /* SCENARIO API */
1861
_dependency_queue_update(RID p_rid,bool p_update_aabb,bool p_update_materials)1862 void VisualServerRaster::_dependency_queue_update(RID p_rid, bool p_update_aabb, bool p_update_materials) {
1863
1864 Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_rid);
1865
1866 if (!E)
1867 return;
1868
1869 Set<RID>::Element *I = E->get().front();
1870
1871 while (I) {
1872
1873 Instance *ins = instance_owner.get(I->get());
1874 _instance_queue_update(ins, p_update_aabb, p_update_materials);
1875
1876 I = I->next();
1877 }
1878 }
1879
_instance_queue_update(Instance * p_instance,bool p_update_aabb,bool p_update_materials)1880 void VisualServerRaster::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_materials) {
1881
1882 if (p_update_aabb)
1883 p_instance->update_aabb = true;
1884 if (p_update_materials)
1885 p_instance->update_materials = true;
1886
1887 if (p_instance->update)
1888 return;
1889 p_instance->update_next = instance_update_list;
1890 instance_update_list = p_instance;
1891 p_instance->update = true;
1892 }
1893
scenario_create()1894 RID VisualServerRaster::scenario_create() {
1895
1896 Scenario *scenario = memnew(Scenario);
1897 ERR_FAIL_COND_V(!scenario, RID());
1898 RID scenario_rid = scenario_owner.make_rid(scenario);
1899 scenario->self = scenario_rid;
1900 scenario->octree.set_pair_callback(instance_pair, this);
1901 scenario->octree.set_unpair_callback(instance_unpair, this);
1902
1903 return scenario_rid;
1904 }
1905
scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode)1906 void VisualServerRaster::scenario_set_debug(RID p_scenario, ScenarioDebugMode p_debug_mode) {
1907 VS_CHANGED;
1908
1909 Scenario *scenario = scenario_owner.get(p_scenario);
1910 ERR_FAIL_COND(!scenario);
1911 scenario->debug = p_debug_mode;
1912 }
1913
scenario_set_environment(RID p_scenario,RID p_environment)1914 void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment) {
1915
1916 VS_CHANGED;
1917
1918 Scenario *scenario = scenario_owner.get(p_scenario);
1919 ERR_FAIL_COND(!scenario);
1920 scenario->environment = p_environment;
1921 }
1922
scenario_set_fallback_environment(RID p_scenario,RID p_environment)1923 void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
1924
1925 VS_CHANGED;
1926
1927 Scenario *scenario = scenario_owner.get(p_scenario);
1928 ERR_FAIL_COND(!scenario);
1929 scenario->fallback_environment = p_environment;
1930 }
1931
scenario_get_environment(RID p_scenario,RID p_environment) const1932 RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const {
1933
1934 const Scenario *scenario = scenario_owner.get(p_scenario);
1935 ERR_FAIL_COND_V(!scenario, RID());
1936 return scenario->environment;
1937 }
1938
1939 /* INSTANCING API */
1940
instance_create()1941 RID VisualServerRaster::instance_create() {
1942
1943 Instance *instance = memnew(Instance);
1944 ERR_FAIL_COND_V(!instance, RID());
1945
1946 RID instance_rid = instance_owner.make_rid(instance);
1947 instance->self = instance_rid;
1948 instance->base_type = INSTANCE_NONE;
1949 instance->scenario = NULL;
1950
1951 return instance_rid;
1952 }
1953
instance_set_base(RID p_instance,RID p_base)1954 void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
1955
1956 VS_CHANGED;
1957 Instance *instance = instance_owner.get(p_instance);
1958 ERR_FAIL_COND(!instance);
1959
1960 if (instance->base_type != INSTANCE_NONE) {
1961 //free anything related to that base
1962
1963 Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(instance->base_rid);
1964
1965 if (E) {
1966 // wtf, no E?
1967 E->get().erase(instance->self);
1968
1969 } else {
1970
1971 ERR_PRINT("no base E? Bug?");
1972 }
1973
1974 if (instance->room) {
1975
1976 instance_set_room(p_instance, RID());
1977 /*
1978 if((1<<instance->base_type)&INSTANCE_GEOMETRY_MASK)
1979 instance->room->room_info->owned_geometry_instances.erase(instance->RE);
1980 else if (instance->base_type==INSTANCE_PORTAL) {
1981 print_line("freeing portal, is it there? "+itos(instance->room->room_info->owned_portal_instances.(instance->RE)));
1982 instance->room->room_info->owned_portal_instances.erase(instance->RE);
1983 } else if (instance->base_type==INSTANCE_ROOM)
1984 instance->room->room_info->owned_room_instances.erase(instance->RE);
1985 else if (instance->base_type==INSTANCE_LIGHT)
1986 instance->room->room_info->owned_light_instances.erase(instance->RE);
1987
1988 instance->RE=NULL;*/
1989 }
1990
1991 if (instance->light_info) {
1992
1993 if (instance->scenario && instance->light_info->D)
1994 instance->scenario->directional_lights.erase(instance->light_info->D);
1995 rasterizer->free(instance->light_info->instance);
1996 memdelete(instance->light_info);
1997 instance->light_info = NULL;
1998 }
1999
2000 if (instance->portal_info) {
2001
2002 _portal_disconnect(instance, true);
2003 memdelete(instance->portal_info);
2004 instance->portal_info = NULL;
2005 }
2006
2007 if (instance->baked_light_info) {
2008
2009 while (instance->baked_light_info->owned_instances.size()) {
2010
2011 Instance *owned = instance->baked_light_info->owned_instances.front()->get();
2012 owned->baked_light = NULL;
2013 owned->data.baked_light = NULL;
2014 owned->data.baked_light_octree_xform = NULL;
2015 owned->BLE = NULL;
2016 instance->baked_light_info->owned_instances.pop_front();
2017 }
2018
2019 memdelete(instance->baked_light_info);
2020 instance->baked_light_info = NULL;
2021 }
2022
2023 if (instance->scenario && instance->octree_id) {
2024 instance->scenario->octree.erase(instance->octree_id);
2025 instance->octree_id = 0;
2026 }
2027
2028 if (instance->room_info) {
2029
2030 for (List<Instance *>::Element *E = instance->room_info->owned_geometry_instances.front(); E; E = E->next()) {
2031
2032 Instance *owned = E->get();
2033 owned->room = NULL;
2034 owned->RE = NULL;
2035 }
2036 for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next()) {
2037
2038 _portal_disconnect(E->get(), true);
2039 Instance *owned = E->get();
2040 owned->room = NULL;
2041 owned->RE = NULL;
2042 }
2043
2044 for (List<Instance *>::Element *E = instance->room_info->owned_room_instances.front(); E; E = E->next()) {
2045
2046 Instance *owned = E->get();
2047 owned->room = NULL;
2048 owned->RE = NULL;
2049 }
2050
2051 if (instance->room_info->disconnected_child_portals.size()) {
2052 ERR_PRINT("BUG: Disconnected portals remain!");
2053 }
2054 memdelete(instance->room_info);
2055 instance->room_info = NULL;
2056 }
2057
2058 if (instance->particles_info) {
2059
2060 rasterizer->free(instance->particles_info->instance);
2061 memdelete(instance->particles_info);
2062 instance->particles_info = NULL;
2063 }
2064
2065 if (instance->baked_light_sampler_info) {
2066
2067 while (instance->baked_light_sampler_info->owned_instances.size()) {
2068
2069 instance_geometry_set_baked_light_sampler(instance->baked_light_sampler_info->owned_instances.front()->get()->self, RID());
2070 }
2071
2072 if (instance->baked_light_sampler_info->sampled_light.is_valid()) {
2073 rasterizer->free(instance->baked_light_sampler_info->sampled_light);
2074 }
2075 memdelete(instance->baked_light_sampler_info);
2076 instance->baked_light_sampler_info = NULL;
2077 }
2078
2079 instance->data.morph_values.clear();
2080 instance->data.materials.clear();
2081 }
2082
2083 instance->base_type = INSTANCE_NONE;
2084 instance->base_rid = RID();
2085
2086 if (p_base.is_valid()) {
2087
2088 if (rasterizer->is_mesh(p_base)) {
2089 instance->base_type = INSTANCE_MESH;
2090 instance->data.morph_values.resize(rasterizer->mesh_get_morph_target_count(p_base));
2091 instance->data.materials.resize(rasterizer->mesh_get_surface_count(p_base));
2092 } else if (rasterizer->is_multimesh(p_base)) {
2093 instance->base_type = INSTANCE_MULTIMESH;
2094 } else if (rasterizer->is_immediate(p_base)) {
2095 instance->base_type = INSTANCE_IMMEDIATE;
2096 } else if (rasterizer->is_particles(p_base)) {
2097 instance->base_type = INSTANCE_PARTICLES;
2098 instance->particles_info = memnew(Instance::ParticlesInfo);
2099 instance->particles_info->instance = rasterizer->particles_instance_create(p_base);
2100 } else if (rasterizer->is_light(p_base)) {
2101
2102 instance->base_type = INSTANCE_LIGHT;
2103 instance->light_info = memnew(Instance::LightInfo);
2104 instance->light_info->instance = rasterizer->light_instance_create(p_base);
2105 if (instance->scenario && rasterizer->light_get_type(p_base) == LIGHT_DIRECTIONAL) {
2106
2107 instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
2108 }
2109
2110 } else if (room_owner.owns(p_base)) {
2111 instance->base_type = INSTANCE_ROOM;
2112 instance->room_info = memnew(Instance::RoomInfo);
2113 instance->room_info->room = room_owner.get(p_base);
2114 } else if (portal_owner.owns(p_base)) {
2115
2116 instance->base_type = INSTANCE_PORTAL;
2117 instance->portal_info = memnew(Instance::PortalInfo);
2118 instance->portal_info->portal = portal_owner.get(p_base);
2119 } else if (baked_light_owner.owns(p_base)) {
2120
2121 instance->base_type = INSTANCE_BAKED_LIGHT;
2122 instance->baked_light_info = memnew(Instance::BakedLightInfo);
2123 instance->baked_light_info->baked_light = baked_light_owner.get(p_base);
2124
2125 //instance->portal_info = memnew(Instance::PortalInfo);
2126 //instance->portal_info->portal=portal_owner.get(p_base);
2127 } else if (baked_light_sampler_owner.owns(p_base)) {
2128
2129 instance->base_type = INSTANCE_BAKED_LIGHT_SAMPLER;
2130 instance->baked_light_sampler_info = memnew(Instance::BakedLightSamplerInfo);
2131 instance->baked_light_sampler_info->sampler = baked_light_sampler_owner.get(p_base);
2132
2133 //instance->portal_info = memnew(Instance::PortalInfo);
2134 //instance->portal_info->portal=portal_owner.get(p_base);
2135
2136 } else {
2137 ERR_EXPLAIN("Invalid base RID for instance!")
2138 ERR_FAIL();
2139 }
2140
2141 instance_dependency_map[p_base].insert(instance->self);
2142
2143 instance->base_rid = p_base;
2144
2145 if (instance->scenario)
2146 _instance_queue_update(instance, true);
2147 }
2148 }
2149
instance_get_base(RID p_instance) const2150 RID VisualServerRaster::instance_get_base(RID p_instance) const {
2151
2152 Instance *instance = instance_owner.get(p_instance);
2153 ERR_FAIL_COND_V(!instance, RID());
2154 return instance->base_rid;
2155 }
2156
instance_set_scenario(RID p_instance,RID p_scenario)2157 void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario) {
2158
2159 VS_CHANGED;
2160
2161 Instance *instance = instance_owner.get(p_instance);
2162 ERR_FAIL_COND(!instance);
2163
2164 if (instance->scenario) {
2165
2166 Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(instance->scenario->self);
2167
2168 if (E) {
2169 // wtf, no E?
2170 E->get().erase(instance->self);
2171
2172 } else {
2173
2174 ERR_PRINT("no scenario E? Bug?");
2175 }
2176
2177 if (instance->light_info) {
2178
2179 if (instance->light_info->D)
2180 instance->scenario->directional_lights.erase(instance->light_info->D);
2181 }
2182
2183 if (instance->portal_info) {
2184
2185 _portal_disconnect(instance, true);
2186 }
2187
2188 if (instance->octree_id) {
2189 instance->scenario->octree.erase(instance->octree_id);
2190 instance->octree_id = 0;
2191 }
2192
2193 instance->scenario = NULL;
2194 }
2195
2196 if (p_scenario.is_valid()) {
2197 Scenario *scenario = scenario_owner.get(p_scenario);
2198 ERR_FAIL_COND(!scenario);
2199
2200 instance->scenario = scenario;
2201
2202 instance_dependency_map[p_scenario].insert(instance->self);
2203 instance->scenario = scenario;
2204
2205 if (instance->base_type == INSTANCE_LIGHT && rasterizer->light_get_type(instance->base_rid) == LIGHT_DIRECTIONAL) {
2206
2207 instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
2208 }
2209
2210 _instance_queue_update(instance, true);
2211 }
2212 }
instance_get_scenario(RID p_instance) const2213 RID VisualServerRaster::instance_get_scenario(RID p_instance) const {
2214
2215 Instance *instance = instance_owner.get(p_instance);
2216 ERR_FAIL_COND_V(!instance, RID());
2217 if (instance->scenario)
2218 return instance->scenario->self;
2219 else
2220 return RID();
2221 }
2222
instance_set_layer_mask(RID p_instance,uint32_t p_mask)2223 void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
2224
2225 VS_CHANGED;
2226
2227 Instance *instance = instance_owner.get(p_instance);
2228 ERR_FAIL_COND(!instance);
2229
2230 instance->layer_mask = p_mask;
2231 }
2232
instance_get_layer_mask(RID p_instance) const2233 uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance) const {
2234
2235 Instance *instance = instance_owner.get(p_instance);
2236 ERR_FAIL_COND_V(!instance, 0);
2237
2238 return instance->layer_mask;
2239 }
2240
instance_get_base_aabb(RID p_instance) const2241 AABB VisualServerRaster::instance_get_base_aabb(RID p_instance) const {
2242
2243 Instance *instance = instance_owner.get(p_instance);
2244 ERR_FAIL_COND_V(!instance, AABB());
2245 return instance->aabb;
2246 }
2247
instance_attach_object_instance_ID(RID p_instance,uint32_t p_ID)2248 void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance, uint32_t p_ID) {
2249 VS_CHANGED;
2250 Instance *instance = instance_owner.get(p_instance);
2251 ERR_FAIL_COND(!instance);
2252
2253 instance->object_ID = p_ID;
2254 }
instance_get_object_instance_ID(RID p_instance) const2255 uint32_t VisualServerRaster::instance_get_object_instance_ID(RID p_instance) const {
2256
2257 Instance *instance = instance_owner.get(p_instance);
2258 ERR_FAIL_COND_V(!instance, 0);
2259 return instance->object_ID;
2260 }
2261
instance_attach_skeleton(RID p_instance,RID p_skeleton)2262 void VisualServerRaster::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
2263 VS_CHANGED;
2264 Instance *instance = instance_owner.get(p_instance);
2265 ERR_FAIL_COND(!instance);
2266
2267 if (instance->data.skeleton.is_valid()) {
2268 skeleton_dependency_map[instance->data.skeleton].erase(instance);
2269 }
2270
2271 instance->data.skeleton = p_skeleton;
2272
2273 if (instance->data.skeleton.is_valid()) {
2274 skeleton_dependency_map[instance->data.skeleton].insert(instance);
2275 }
2276 }
2277
instance_get_skeleton(RID p_instance) const2278 RID VisualServerRaster::instance_get_skeleton(RID p_instance) const {
2279
2280 Instance *instance = instance_owner.get(p_instance);
2281 ERR_FAIL_COND_V(!instance, RID());
2282 return instance->data.skeleton;
2283 }
2284
instance_set_morph_target_weight(RID p_instance,int p_shape,float p_weight)2285 void VisualServerRaster::instance_set_morph_target_weight(RID p_instance, int p_shape, float p_weight) {
2286
2287 VS_CHANGED;
2288 Instance *instance = instance_owner.get(p_instance);
2289 ERR_FAIL_COND(!instance);
2290 ERR_FAIL_INDEX(p_shape, instance->data.morph_values.size());
2291 instance->data.morph_values[p_shape] = p_weight;
2292 }
2293
instance_get_morph_target_weight(RID p_instance,int p_shape) const2294 float VisualServerRaster::instance_get_morph_target_weight(RID p_instance, int p_shape) const {
2295
2296 Instance *instance = instance_owner.get(p_instance);
2297 ERR_FAIL_COND_V(!instance, 0);
2298 ERR_FAIL_INDEX_V(p_shape, instance->data.morph_values.size(), 0);
2299 return instance->data.morph_values[p_shape];
2300 }
2301
instance_set_surface_material(RID p_instance,int p_surface,RID p_material)2302 void VisualServerRaster::instance_set_surface_material(RID p_instance, int p_surface, RID p_material) {
2303
2304 VS_CHANGED;
2305 Instance *instance = instance_owner.get(p_instance);
2306 ERR_FAIL_COND(!instance);
2307 ERR_FAIL_INDEX(p_surface, instance->data.materials.size());
2308 instance->data.materials[p_surface] = p_material;
2309 }
2310
instance_set_transform(RID p_instance,const Transform & p_transform)2311 void VisualServerRaster::instance_set_transform(RID p_instance, const Transform &p_transform) {
2312 VS_CHANGED;
2313 Instance *instance = instance_owner.get(p_instance);
2314 ERR_FAIL_COND(!instance);
2315
2316 if (p_transform == instance->data.transform) // must improve somehow
2317 return;
2318
2319 instance->data.transform = p_transform;
2320 if (instance->base_type == INSTANCE_LIGHT)
2321 instance->data.transform.orthonormalize();
2322 _instance_queue_update(instance);
2323 }
2324
instance_get_transform(RID p_instance) const2325 Transform VisualServerRaster::instance_get_transform(RID p_instance) const {
2326
2327 Instance *instance = instance_owner.get(p_instance);
2328 ERR_FAIL_COND_V(!instance, Transform());
2329
2330 return instance->data.transform;
2331 }
2332
instance_set_exterior(RID p_instance,bool p_enabled)2333 void VisualServerRaster::instance_set_exterior(RID p_instance, bool p_enabled) {
2334 VS_CHANGED;
2335 Instance *instance = instance_owner.get(p_instance);
2336 ERR_FAIL_COND(!instance);
2337
2338 ERR_EXPLAIN("Portals can't be assigned to be exterior");
2339
2340 ERR_FAIL_COND(instance->base_type == INSTANCE_PORTAL);
2341 if (instance->exterior == p_enabled)
2342 return;
2343 instance->exterior = p_enabled;
2344 _instance_queue_update(instance);
2345 }
2346
instance_is_exterior(RID p_instance) const2347 bool VisualServerRaster::instance_is_exterior(RID p_instance) const {
2348
2349 Instance *instance = instance_owner.get(p_instance);
2350 ERR_FAIL_COND_V(!instance, false);
2351
2352 return instance->exterior;
2353 }
2354
instance_set_room(RID p_instance,RID p_room)2355 void VisualServerRaster::instance_set_room(RID p_instance, RID p_room) {
2356 VS_CHANGED;
2357
2358 Instance *instance = instance_owner.get(p_instance);
2359 ERR_FAIL_COND(!instance);
2360
2361 if (instance->room && instance->RE) {
2362
2363 //instance already havs a room, remove it from there
2364
2365 if ((1 << instance->base_type) & INSTANCE_GEOMETRY_MASK) {
2366
2367 instance->room->room_info->owned_geometry_instances.erase(instance->RE);
2368
2369 if (!p_room.is_valid() && instance->octree_id) {
2370 //remove from the octree, so it's re-added with different flags
2371 instance->scenario->octree.erase(instance->octree_id);
2372 instance->octree_id = 0;
2373 _instance_queue_update(instance, true);
2374 }
2375
2376 } else if (instance->base_type == INSTANCE_ROOM) {
2377
2378 instance->room->room_info->owned_room_instances.erase(instance->RE);
2379
2380 for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next()) {
2381 _portal_disconnect(E->get());
2382 _instance_queue_update(E->get(), false);
2383 }
2384
2385 } else if (instance->base_type == INSTANCE_PORTAL) {
2386
2387 _portal_disconnect(instance, true);
2388 bool ss = instance->room->room_info->owned_portal_instances.erase(instance->RE);
2389
2390 } else if (instance->base_type == INSTANCE_LIGHT) {
2391
2392 instance->room->room_info->owned_light_instances.erase(instance->RE);
2393 } else {
2394
2395 ERR_FAIL();
2396 }
2397
2398 instance->RE = NULL;
2399 instance->room = NULL;
2400
2401 } else {
2402
2403 if (p_room.is_valid() && instance->octree_id) {
2404 //remove from the octree, so it's re-added with different flags
2405 instance->scenario->octree.erase(instance->octree_id);
2406 instance->octree_id = 0;
2407 _instance_queue_update(instance, true);
2408 }
2409 }
2410
2411 if (!p_room.is_valid())
2412 return; // just clearning the room
2413
2414 Instance *room = instance_owner.get(p_room);
2415
2416 ERR_FAIL_COND(!room);
2417 ERR_FAIL_COND(room->base_type != INSTANCE_ROOM);
2418
2419 if (instance->base_type == INSTANCE_ROOM) {
2420
2421 //perform cycle test
2422
2423 Instance *parent = instance;
2424
2425 while (parent) {
2426
2427 ERR_EXPLAIN("Cycle in room assignment");
2428 ERR_FAIL_COND(parent == room);
2429 parent = parent->room;
2430 }
2431 }
2432
2433 if ((1 << instance->base_type) & INSTANCE_GEOMETRY_MASK) {
2434
2435 instance->RE = room->room_info->owned_geometry_instances.push_back(instance);
2436 } else if (instance->base_type == INSTANCE_ROOM) {
2437
2438 instance->RE = room->room_info->owned_room_instances.push_back(instance);
2439 for (List<Instance *>::Element *E = instance->room_info->owned_portal_instances.front(); E; E = E->next())
2440 _instance_queue_update(E->get(), false);
2441
2442 } else if (instance->base_type == INSTANCE_PORTAL) {
2443
2444 instance->RE = room->room_info->owned_portal_instances.push_back(instance);
2445 } else if (instance->base_type == INSTANCE_LIGHT) {
2446
2447 instance->RE = room->room_info->owned_light_instances.push_back(instance);
2448 } else {
2449
2450 ERR_FAIL();
2451 }
2452
2453 instance->room = room;
2454 }
2455
instance_get_room(RID p_instance) const2456 RID VisualServerRaster::instance_get_room(RID p_instance) const {
2457
2458 Instance *instance = instance_owner.get(p_instance);
2459 ERR_FAIL_COND_V(!instance, RID());
2460
2461 if (instance->room)
2462 return instance->room->self;
2463 else
2464 return RID();
2465 }
2466
instance_set_extra_visibility_margin(RID p_instance,real_t p_margin)2467 void VisualServerRaster::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
2468
2469 VS_CHANGED;
2470
2471 Instance *instance = instance_owner.get(p_instance);
2472 ERR_FAIL_COND(!instance);
2473
2474 instance->extra_margin = p_margin;
2475 }
instance_get_extra_visibility_margin(RID p_instance) const2476 real_t VisualServerRaster::instance_get_extra_visibility_margin(RID p_instance) const {
2477
2478 Instance *instance = instance_owner.get(p_instance);
2479 ERR_FAIL_COND_V(!instance, 0);
2480
2481 return instance->extra_margin;
2482 }
2483
instances_cull_aabb(const AABB & p_aabb,RID p_scenario) const2484 Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
2485
2486 Vector<RID> instances;
2487 Scenario *scenario = scenario_owner.get(p_scenario);
2488 ERR_FAIL_COND_V(!scenario, instances);
2489
2490 const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
2491
2492 int culled = 0;
2493 Instance *cull[1024];
2494 culled = scenario->octree.cull_AABB(p_aabb, cull, 1024);
2495
2496 for (int i = 0; i < culled; i++) {
2497
2498 Instance *instance = cull[i];
2499 ERR_CONTINUE(!instance);
2500 instances.push_back(instance->self);
2501 }
2502
2503 return instances;
2504 }
instances_cull_ray(const Vector3 & p_from,const Vector3 & p_to,RID p_scenario) const2505 Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
2506
2507 Vector<RID> instances;
2508 Scenario *scenario = scenario_owner.get(p_scenario);
2509 ERR_FAIL_COND_V(!scenario, instances);
2510 const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
2511
2512 int culled = 0;
2513 Instance *cull[1024];
2514 culled = scenario->octree.cull_segment(p_from, p_to * 10000, cull, 1024);
2515
2516 for (int i = 0; i < culled; i++) {
2517
2518 Instance *instance = cull[i];
2519 ERR_CONTINUE(!instance);
2520 instances.push_back(instance->self);
2521 }
2522
2523 return instances;
2524 }
instances_cull_convex(const Vector<Plane> & p_convex,RID p_scenario) const2525 Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
2526
2527 Vector<RID> instances;
2528 Scenario *scenario = scenario_owner.get(p_scenario);
2529 ERR_FAIL_COND_V(!scenario, instances);
2530 const_cast<VisualServerRaster *>(this)->_update_instances(); // check dirty instances before culling
2531
2532 int culled = 0;
2533 Instance *cull[1024];
2534
2535 culled = scenario->octree.cull_convex(p_convex, cull, 1024);
2536
2537 for (int i = 0; i < culled; i++) {
2538
2539 Instance *instance = cull[i];
2540 ERR_CONTINUE(!instance);
2541 instances.push_back(instance->self);
2542 }
2543
2544 return instances;
2545 }
2546
instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled)2547 void VisualServerRaster::instance_geometry_set_flag(RID p_instance, InstanceFlags p_flags, bool p_enabled) {
2548
2549 Instance *instance = instance_owner.get(p_instance);
2550 ERR_FAIL_COND(!instance);
2551 // ERR_FAIL_COND( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK) );
2552
2553 switch (p_flags) {
2554
2555 case INSTANCE_FLAG_VISIBLE: {
2556
2557 instance->visible = p_enabled;
2558
2559 } break;
2560 case INSTANCE_FLAG_BILLBOARD: {
2561
2562 instance->data.billboard = p_enabled;
2563
2564 } break;
2565 case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
2566
2567 instance->data.billboard_y = p_enabled;
2568
2569 } break;
2570 case INSTANCE_FLAG_CAST_SHADOW: {
2571 if (p_enabled == true) {
2572 instance->data.cast_shadows = SHADOW_CASTING_SETTING_ON;
2573 } else {
2574 instance->data.cast_shadows = SHADOW_CASTING_SETTING_OFF;
2575 }
2576
2577 } break;
2578 case INSTANCE_FLAG_RECEIVE_SHADOWS: {
2579
2580 instance->data.receive_shadows = p_enabled;
2581
2582 } break;
2583 case INSTANCE_FLAG_DEPH_SCALE: {
2584
2585 instance->data.depth_scale = p_enabled;
2586
2587 } break;
2588 case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
2589
2590 instance->visible_in_all_rooms = p_enabled;
2591
2592 } break;
2593 }
2594 }
2595
instance_geometry_get_flag(RID p_instance,InstanceFlags p_flags) const2596 bool VisualServerRaster::instance_geometry_get_flag(RID p_instance, InstanceFlags p_flags) const {
2597
2598 const Instance *instance = instance_owner.get(p_instance);
2599 ERR_FAIL_COND_V(!instance, false);
2600 // ERR_FAIL_COND_V( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK), false );
2601
2602 switch (p_flags) {
2603
2604 case INSTANCE_FLAG_VISIBLE: {
2605
2606 return instance->visible;
2607
2608 } break;
2609 case INSTANCE_FLAG_BILLBOARD: {
2610
2611 return instance->data.billboard;
2612
2613 } break;
2614 case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
2615
2616 return instance->data.billboard_y;
2617
2618 } break;
2619 case INSTANCE_FLAG_CAST_SHADOW: {
2620 if (instance->data.cast_shadows == SHADOW_CASTING_SETTING_OFF) {
2621 return false;
2622 } else {
2623 return true;
2624 }
2625
2626 } break;
2627 case INSTANCE_FLAG_RECEIVE_SHADOWS: {
2628
2629 return instance->data.receive_shadows;
2630
2631 } break;
2632 case INSTANCE_FLAG_DEPH_SCALE: {
2633
2634 return instance->data.depth_scale;
2635
2636 } break;
2637 case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
2638
2639 return instance->visible_in_all_rooms;
2640
2641 } break;
2642 }
2643
2644 return false;
2645 }
2646
instance_geometry_set_cast_shadows_setting(RID p_instance,VS::ShadowCastingSetting p_shadow_casting_setting)2647 void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting) {
2648
2649 Instance *instance = instance_owner.get(p_instance);
2650 ERR_FAIL_COND(!instance);
2651
2652 instance->data.cast_shadows = p_shadow_casting_setting;
2653 }
2654
instance_geometry_get_cast_shadows_setting(RID p_instance) const2655 VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance) const {
2656
2657 const Instance *instance = instance_owner.get(p_instance);
2658 ERR_FAIL_COND_V(!instance, SHADOW_CASTING_SETTING_OFF);
2659
2660 return instance->data.cast_shadows;
2661 }
2662
instance_geometry_set_material_override(RID p_instance,RID p_material)2663 void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material) {
2664
2665 VS_CHANGED;
2666 Instance *instance = instance_owner.get(p_instance);
2667 ERR_FAIL_COND(!instance);
2668 instance->data.material_override = p_material;
2669 }
2670
instance_geometry_get_material_override(RID p_instance) const2671 RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance) const {
2672
2673 Instance *instance = instance_owner.get(p_instance);
2674 ERR_FAIL_COND_V(!instance, RID());
2675 return instance->data.material_override;
2676 }
2677
instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max)2678 void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max) {
2679
2680 VS_CHANGED;
2681 Instance *instance = instance_owner.get(p_instance);
2682 ERR_FAIL_COND(!instance);
2683
2684 instance->draw_range_begin = p_min;
2685 instance->draw_range_end = p_max;
2686 }
2687
instance_geometry_get_draw_range_min(RID p_instance) const2688 float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance) const {
2689
2690 const Instance *instance = instance_owner.get(p_instance);
2691 ERR_FAIL_COND_V(!instance, 0);
2692
2693 return instance->draw_range_begin;
2694 }
2695
instance_geometry_get_draw_range_max(RID p_instance) const2696 float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance) const {
2697
2698 const Instance *instance = instance_owner.get(p_instance);
2699 ERR_FAIL_COND_V(!instance, 0);
2700
2701 return instance->draw_range_end;
2702 }
2703
instance_geometry_set_baked_light(RID p_instance,RID p_baked_light)2704 void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance, RID p_baked_light) {
2705
2706 VS_CHANGED;
2707 Instance *instance = instance_owner.get(p_instance);
2708 ERR_FAIL_COND(!instance);
2709
2710 if (instance->baked_light) {
2711
2712 instance->baked_light->baked_light_info->owned_instances.erase(instance->BLE);
2713 instance->BLE = NULL;
2714 instance->baked_light = NULL;
2715 instance->data.baked_light = NULL;
2716 instance->data.baked_light_octree_xform = NULL;
2717 }
2718
2719 if (!p_baked_light.is_valid())
2720 return;
2721 Instance *bl_instance = instance_owner.get(p_baked_light);
2722 ERR_FAIL_COND(!bl_instance);
2723 ERR_FAIL_COND(bl_instance->base_type != INSTANCE_BAKED_LIGHT);
2724
2725 instance->baked_light = bl_instance;
2726 instance->BLE = bl_instance->baked_light_info->owned_instances.push_back(instance);
2727 instance->data.baked_light = &bl_instance->baked_light_info->baked_light->data;
2728 instance->data.baked_light_octree_xform = &bl_instance->baked_light_info->affine_inverse;
2729 }
2730
instance_geometry_get_baked_light(RID p_instance) const2731 RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance) const {
2732
2733 const Instance *instance = instance_owner.get(p_instance);
2734 ERR_FAIL_COND_V(!instance, RID());
2735 if (instance->baked_light)
2736 return instance->baked_light->self;
2737 return RID();
2738 }
2739
instance_geometry_set_baked_light_sampler(RID p_instance,RID p_baked_light_sampler)2740 void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance, RID p_baked_light_sampler) {
2741
2742 VS_CHANGED;
2743 Instance *instance = instance_owner.get(p_instance);
2744 ERR_FAIL_COND(!instance);
2745
2746 if (instance->sampled_light) {
2747 instance->sampled_light->baked_light_sampler_info->owned_instances.erase(instance);
2748 instance->data.sampled_light = RID();
2749 }
2750
2751 if (p_baked_light_sampler.is_valid()) {
2752 Instance *sampler_instance = instance_owner.get(p_baked_light_sampler);
2753 ERR_FAIL_COND(!sampler_instance);
2754 ERR_FAIL_COND(sampler_instance->base_type != INSTANCE_BAKED_LIGHT_SAMPLER);
2755 instance->sampled_light = sampler_instance;
2756 instance->sampled_light->baked_light_sampler_info->owned_instances.insert(instance);
2757 } else {
2758 instance->sampled_light = NULL;
2759 }
2760
2761 instance->data.sampled_light = RID();
2762 }
2763
instance_geometry_get_baked_light_sampler(RID p_instance) const2764 RID VisualServerRaster::instance_geometry_get_baked_light_sampler(RID p_instance) const {
2765
2766 Instance *instance = instance_owner.get(p_instance);
2767 ERR_FAIL_COND_V(!instance, RID());
2768
2769 if (instance->sampled_light)
2770 return instance->sampled_light->self;
2771 else
2772 return RID();
2773 }
2774
instance_geometry_set_baked_light_texture_index(RID p_instance,int p_tex_id)2775 void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance, int p_tex_id) {
2776
2777 VS_CHANGED;
2778 Instance *instance = instance_owner.get(p_instance);
2779 ERR_FAIL_COND(!instance);
2780
2781 instance->data.baked_lightmap_id = p_tex_id;
2782 }
instance_geometry_get_baked_light_texture_index(RID p_instance) const2783 int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance) const {
2784
2785 const Instance *instance = instance_owner.get(p_instance);
2786 ERR_FAIL_COND_V(!instance, 0);
2787
2788 return instance->data.baked_lightmap_id;
2789 }
2790
_update_instance(Instance * p_instance)2791 void VisualServerRaster::_update_instance(Instance *p_instance) {
2792
2793 p_instance->version++;
2794
2795 if (p_instance->base_type == INSTANCE_LIGHT) {
2796
2797 rasterizer->light_instance_set_transform(p_instance->light_info->instance, p_instance->data.transform);
2798 }
2799
2800 if (p_instance->aabb.has_no_surface())
2801 return;
2802
2803 if (p_instance->base_type == INSTANCE_PARTICLES) {
2804
2805 rasterizer->particles_instance_set_transform(p_instance->particles_info->instance, p_instance->data.transform);
2806 }
2807
2808 if ((1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
2809
2810 //make sure lights are updated
2811 InstanceSet::Element *E = p_instance->lights.front();
2812 while (E) {
2813
2814 E->get()->version++;
2815 E = E->next();
2816 }
2817
2818 } else if (p_instance->base_type == INSTANCE_ROOM) {
2819
2820 p_instance->room_info->affine_inverse = p_instance->data.transform.affine_inverse();
2821 } else if (p_instance->base_type == INSTANCE_BAKED_LIGHT) {
2822
2823 Transform scale;
2824 scale.basis.scale(p_instance->baked_light_info->baked_light->octree_aabb.size);
2825 scale.origin = p_instance->baked_light_info->baked_light->octree_aabb.pos;
2826 //print_line("scale: "+scale);
2827 p_instance->baked_light_info->affine_inverse = (p_instance->data.transform * scale).affine_inverse();
2828 }
2829
2830 p_instance->data.mirror = p_instance->data.transform.basis.determinant() < 0.0;
2831
2832 AABB new_aabb;
2833
2834 if (p_instance->base_type == INSTANCE_PORTAL) {
2835
2836 //portals need to be transformed in a special way, so they don't become too wide if they have scale..
2837 Transform portal_xform = p_instance->data.transform;
2838 portal_xform.basis.set_axis(2, portal_xform.basis.get_axis(2).normalized());
2839
2840 p_instance->portal_info->plane_cache = Plane(p_instance->data.transform.origin, portal_xform.basis.get_axis(2));
2841 int point_count = p_instance->portal_info->portal->shape.size();
2842 p_instance->portal_info->transformed_point_cache.resize(point_count);
2843
2844 AABB portal_aabb;
2845
2846 for (int i = 0; i < point_count; i++) {
2847
2848 Point2 src = p_instance->portal_info->portal->shape[i];
2849 Vector3 point = portal_xform.xform(Vector3(src.x, src.y, 0));
2850 p_instance->portal_info->transformed_point_cache[i] = point;
2851 if (i == 0)
2852 portal_aabb.pos = point;
2853 else
2854 portal_aabb.expand_to(point);
2855 }
2856
2857 portal_aabb.grow_by(p_instance->portal_info->portal->connect_range);
2858
2859 new_aabb = portal_aabb;
2860
2861 } else {
2862
2863 new_aabb = p_instance->data.transform.xform(p_instance->aabb);
2864 }
2865
2866 for (InstanceSet::Element *E = p_instance->lights.front(); E; E = E->next()) {
2867 Instance *light = E->get();
2868 light->version++;
2869 }
2870
2871 p_instance->transformed_aabb = new_aabb;
2872
2873 if (!p_instance->scenario) {
2874
2875 return;
2876 }
2877
2878 if (p_instance->octree_id == 0) {
2879
2880 uint32_t base_type = 1 << p_instance->base_type;
2881 uint32_t pairable_mask = 0;
2882 bool pairable = false;
2883
2884 if (p_instance->base_type == INSTANCE_LIGHT) {
2885
2886 pairable_mask = p_instance->light_info->enabled ? INSTANCE_GEOMETRY_MASK : 0;
2887 pairable = true;
2888 }
2889
2890 if (p_instance->base_type == INSTANCE_PORTAL) {
2891
2892 pairable_mask = (1 << INSTANCE_PORTAL);
2893 pairable = true;
2894 }
2895
2896 if (p_instance->base_type == INSTANCE_BAKED_LIGHT_SAMPLER) {
2897
2898 pairable_mask = (1 << INSTANCE_BAKED_LIGHT);
2899 pairable = true;
2900 }
2901
2902 if (!p_instance->room && (1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
2903
2904 base_type |= INSTANCE_ROOMLESS_MASK;
2905 }
2906
2907 if (p_instance->base_type == INSTANCE_ROOM) {
2908
2909 pairable_mask = INSTANCE_ROOMLESS_MASK;
2910 pairable = true;
2911 }
2912
2913 // not inside octree
2914 p_instance->octree_id = p_instance->scenario->octree.create(p_instance, new_aabb, 0, pairable, base_type, pairable_mask);
2915
2916 } else {
2917
2918 // if (new_aabb==p_instance->data.transformed_aabb)
2919 // return;
2920
2921 p_instance->scenario->octree.move(p_instance->octree_id, new_aabb);
2922 }
2923
2924 if (p_instance->base_type == INSTANCE_PORTAL) {
2925
2926 _portal_attempt_connect(p_instance);
2927 }
2928
2929 if (!p_instance->room && (1 << p_instance->base_type) & INSTANCE_GEOMETRY_MASK) {
2930
2931 _instance_validate_autorooms(p_instance);
2932 }
2933
2934 if (p_instance->base_type == INSTANCE_ROOM) {
2935
2936 for (Set<Instance *>::Element *E = p_instance->room_info->owned_autoroom_geometry.front(); E; E = E->next())
2937 _instance_validate_autorooms(E->get());
2938 }
2939 }
2940
_update_instance_aabb(Instance * p_instance)2941 void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
2942
2943 AABB new_aabb;
2944
2945 ERR_FAIL_COND(p_instance->base_type != INSTANCE_NONE && !p_instance->base_rid.is_valid());
2946
2947 switch (p_instance->base_type) {
2948 case VisualServer::INSTANCE_NONE: {
2949
2950 // do nothing
2951 } break;
2952 case VisualServer::INSTANCE_MESH: {
2953
2954 new_aabb = rasterizer->mesh_get_aabb(p_instance->base_rid, p_instance->data.skeleton);
2955
2956 } break;
2957 case VisualServer::INSTANCE_MULTIMESH: {
2958
2959 new_aabb = rasterizer->multimesh_get_aabb(p_instance->base_rid);
2960
2961 } break;
2962 case VisualServer::INSTANCE_IMMEDIATE: {
2963
2964 new_aabb = rasterizer->immediate_get_aabb(p_instance->base_rid);
2965
2966 } break;
2967 case VisualServer::INSTANCE_PARTICLES: {
2968
2969 new_aabb = rasterizer->particles_get_aabb(p_instance->base_rid);
2970
2971 } break;
2972 case VisualServer::INSTANCE_LIGHT: {
2973
2974 new_aabb = rasterizer->light_get_aabb(p_instance->base_rid);
2975
2976 } break;
2977 case VisualServer::INSTANCE_ROOM: {
2978
2979 Room *room = room_owner.get(p_instance->base_rid);
2980 ERR_FAIL_COND(!room);
2981 new_aabb = room->bounds.get_aabb();
2982
2983 } break;
2984 case VisualServer::INSTANCE_PORTAL: {
2985
2986 Portal *portal = portal_owner.get(p_instance->base_rid);
2987 ERR_FAIL_COND(!portal);
2988 for (int i = 0; i < portal->shape.size(); i++) {
2989
2990 Vector3 point(portal->shape[i].x, portal->shape[i].y, 0);
2991 if (i == 0) {
2992
2993 new_aabb.pos = point;
2994 new_aabb.size.z = 0.01; // make it not flat for octree
2995 } else {
2996
2997 new_aabb.expand_to(point);
2998 }
2999 }
3000
3001 } break;
3002 case VisualServer::INSTANCE_BAKED_LIGHT: {
3003
3004 BakedLight *baked_light = baked_light_owner.get(p_instance->base_rid);
3005 ERR_FAIL_COND(!baked_light);
3006 new_aabb = baked_light->octree_aabb;
3007
3008 } break;
3009 case VisualServer::INSTANCE_BAKED_LIGHT_SAMPLER: {
3010
3011 BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get(p_instance->base_rid);
3012 ERR_FAIL_COND(!baked_light_sampler);
3013 float radius = baked_light_sampler->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
3014
3015 new_aabb = AABB(Vector3(-radius, -radius, -radius), Vector3(radius * 2, radius * 2, radius * 2));
3016
3017 } break;
3018
3019 default: {}
3020 }
3021
3022 if (p_instance->extra_margin)
3023 new_aabb.grow_by(p_instance->extra_margin);
3024
3025 p_instance->aabb = new_aabb;
3026 }
3027
_update_instances()3028 void VisualServerRaster::_update_instances() {
3029
3030 while (instance_update_list) {
3031
3032 Instance *instance = instance_update_list;
3033
3034 instance_update_list = instance_update_list->update_next;
3035
3036 if (instance->update_aabb)
3037 _update_instance_aabb(instance);
3038
3039 if (instance->update_materials) {
3040 if (instance->base_type == INSTANCE_MESH) {
3041 instance->data.materials.resize(rasterizer->mesh_get_surface_count(instance->base_rid));
3042 }
3043 }
3044
3045 _update_instance(instance);
3046
3047 instance->update = false;
3048 instance->update_aabb = false;
3049 instance->update_materials = false;
3050 instance->update_next = 0;
3051 }
3052 }
3053
instance_light_set_enabled(RID p_instance,bool p_enabled)3054 void VisualServerRaster::instance_light_set_enabled(RID p_instance, bool p_enabled) {
3055
3056 VS_CHANGED;
3057 Instance *instance = instance_owner.get(p_instance);
3058 ERR_FAIL_COND(!instance);
3059 ERR_FAIL_COND(instance->base_type != INSTANCE_LIGHT);
3060
3061 if (p_enabled == instance->light_info->enabled)
3062 return;
3063
3064 instance->light_info->enabled = p_enabled;
3065 if (light_get_type(instance->base_rid) != VS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario)
3066 instance->scenario->octree.set_pairable(instance->octree_id, p_enabled, 1 << INSTANCE_LIGHT, p_enabled ? INSTANCE_GEOMETRY_MASK : 0);
3067
3068 //_instance_queue_update( instance , true );
3069 }
3070
instance_light_is_enabled(RID p_instance) const3071 bool VisualServerRaster::instance_light_is_enabled(RID p_instance) const {
3072
3073 const Instance *instance = instance_owner.get(p_instance);
3074 ERR_FAIL_COND_V(!instance, false);
3075 ERR_FAIL_COND_V(instance->base_type != INSTANCE_LIGHT, false);
3076
3077 return instance->light_info->enabled;
3078 }
3079
3080 /****** CANVAS *********/
canvas_create()3081 RID VisualServerRaster::canvas_create() {
3082
3083 Canvas *canvas = memnew(Canvas);
3084 ERR_FAIL_COND_V(!canvas, RID());
3085 RID rid = canvas_owner.make_rid(canvas);
3086
3087 return rid;
3088 }
3089
canvas_set_item_mirroring(RID p_canvas,RID p_item,const Point2 & p_mirroring)3090 void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
3091
3092 Canvas *canvas = canvas_owner.get(p_canvas);
3093 ERR_FAIL_COND(!canvas);
3094 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3095 ERR_FAIL_COND(!canvas_item);
3096
3097 int idx = canvas->find_item(canvas_item);
3098 ERR_FAIL_COND(idx == -1);
3099 canvas->child_items[idx].mirror = p_mirroring;
3100 }
3101
canvas_get_item_mirroring(RID p_canvas,RID p_item) const3102 Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas, RID p_item) const {
3103
3104 Canvas *canvas = canvas_owner.get(p_canvas);
3105 ERR_FAIL_COND_V(!canvas, Point2());
3106 CanvasItem *canvas_item = memnew(CanvasItem);
3107 ERR_FAIL_COND_V(!canvas_item, Point2());
3108
3109 int idx = canvas->find_item(canvas_item);
3110 ERR_FAIL_COND_V(idx == -1, Point2());
3111 return canvas->child_items[idx].mirror;
3112 }
3113
canvas_set_modulate(RID p_canvas,const Color & p_color)3114 void VisualServerRaster::canvas_set_modulate(RID p_canvas, const Color &p_color) {
3115
3116 Canvas *canvas = canvas_owner.get(p_canvas);
3117 ERR_FAIL_COND(!canvas);
3118 canvas->modulate = p_color;
3119 }
3120
canvas_item_create()3121 RID VisualServerRaster::canvas_item_create() {
3122
3123 CanvasItem *canvas_item = memnew(CanvasItem);
3124 ERR_FAIL_COND_V(!canvas_item, RID());
3125
3126 return canvas_item_owner.make_rid(canvas_item);
3127 }
3128
canvas_item_set_parent(RID p_item,RID p_parent)3129 void VisualServerRaster::canvas_item_set_parent(RID p_item, RID p_parent) {
3130
3131 VS_CHANGED;
3132 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3133 ERR_FAIL_COND(!canvas_item);
3134
3135 if (canvas_item->parent.is_valid()) {
3136
3137 if (canvas_owner.owns(canvas_item->parent)) {
3138
3139 Canvas *canvas = canvas_owner.get(canvas_item->parent);
3140 canvas->erase_item(canvas_item);
3141 } else if (canvas_item_owner.owns(canvas_item->parent)) {
3142
3143 CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
3144 item_owner->child_items.erase(canvas_item);
3145 }
3146
3147 canvas_item->parent = RID();
3148 }
3149
3150 if (p_parent.is_valid()) {
3151 if (canvas_owner.owns(p_parent)) {
3152
3153 Canvas *canvas = canvas_owner.get(p_parent);
3154 Canvas::ChildItem ci;
3155 ci.item = canvas_item;
3156 canvas->child_items.push_back(ci);
3157 } else if (canvas_item_owner.owns(p_parent)) {
3158
3159 CanvasItem *item_owner = canvas_item_owner.get(p_parent);
3160 item_owner->child_items.push_back(canvas_item);
3161
3162 } else {
3163
3164 ERR_EXPLAIN("Invalid parent");
3165 ERR_FAIL();
3166 }
3167 }
3168
3169 canvas_item->parent = p_parent;
3170 }
3171
canvas_item_get_parent(RID p_canvas_item) const3172 RID VisualServerRaster::canvas_item_get_parent(RID p_canvas_item) const {
3173
3174 CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
3175 ERR_FAIL_COND_V(!canvas_item, RID());
3176
3177 return canvas_item->parent;
3178 }
3179
canvas_item_set_visible(RID p_item,bool p_visible)3180 void VisualServerRaster::canvas_item_set_visible(RID p_item, bool p_visible) {
3181
3182 VS_CHANGED;
3183
3184 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3185 ERR_FAIL_COND(!canvas_item);
3186
3187 canvas_item->visible = p_visible;
3188 }
3189
canvas_item_is_visible(RID p_item) const3190 bool VisualServerRaster::canvas_item_is_visible(RID p_item) const {
3191
3192 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3193 ERR_FAIL_COND_V(!canvas_item, RID());
3194
3195 return canvas_item->visible;
3196 }
3197
canvas_item_set_light_mask(RID p_canvas_item,int p_mask)3198 void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item, int p_mask) {
3199
3200 VS_CHANGED;
3201
3202 CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
3203 ERR_FAIL_COND(!canvas_item);
3204
3205 if (canvas_item->light_mask == p_mask)
3206 return;
3207 VS_CHANGED;
3208
3209 canvas_item->light_mask = p_mask;
3210 }
3211
canvas_item_set_blend_mode(RID p_canvas_item,MaterialBlendMode p_blend)3212 void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item, MaterialBlendMode p_blend) {
3213
3214 VS_CHANGED;
3215
3216 CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
3217 ERR_FAIL_COND(!canvas_item);
3218
3219 if (canvas_item->blend_mode == p_blend)
3220 return;
3221 VS_CHANGED;
3222
3223 canvas_item->blend_mode = p_blend;
3224 }
3225
canvas_item_attach_viewport(RID p_canvas_item,RID p_viewport)3226 void VisualServerRaster::canvas_item_attach_viewport(RID p_canvas_item, RID p_viewport) {
3227
3228 CanvasItem *canvas_item = canvas_item_owner.get(p_canvas_item);
3229 ERR_FAIL_COND(!canvas_item);
3230
3231 VS_CHANGED;
3232
3233 canvas_item->viewport = p_viewport;
3234 }
3235
3236 /*
3237 void VisualServerRaster::canvas_item_set_rect(RID p_item, const Rect2& p_rect) {
3238 VS_CHANGED;
3239 CanvasItem *canvas_item = canvas_item_owner.get( p_item );
3240 ERR_FAIL_COND(!canvas_item);
3241
3242 canvas_item->rect=p_rect;
3243 }*/
3244
canvas_item_set_clip(RID p_item,bool p_clip)3245 void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip) {
3246 VS_CHANGED;
3247 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3248 ERR_FAIL_COND(!canvas_item);
3249
3250 canvas_item->clip = p_clip;
3251 }
3252
canvas_item_set_distance_field_mode(RID p_item,bool p_distance_field)3253 void VisualServerRaster::canvas_item_set_distance_field_mode(RID p_item, bool p_distance_field) {
3254 VS_CHANGED;
3255 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3256 ERR_FAIL_COND(!canvas_item);
3257
3258 canvas_item->distance_field = p_distance_field;
3259 }
3260
canvas_item_set_transform(RID p_item,const Matrix32 & p_transform)3261 void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32 &p_transform) {
3262
3263 VS_CHANGED;
3264 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3265 ERR_FAIL_COND(!canvas_item);
3266
3267 canvas_item->xform = p_transform;
3268 }
3269
canvas_item_set_custom_rect(RID p_item,bool p_custom_rect,const Rect2 & p_rect)3270 void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
3271 VS_CHANGED;
3272 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3273 ERR_FAIL_COND(!canvas_item);
3274
3275 canvas_item->custom_rect = p_custom_rect;
3276 if (p_custom_rect)
3277 canvas_item->rect = p_rect;
3278 }
3279
canvas_item_set_opacity(RID p_item,float p_opacity)3280 void VisualServerRaster::canvas_item_set_opacity(RID p_item, float p_opacity) {
3281 VS_CHANGED;
3282 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3283 ERR_FAIL_COND(!canvas_item);
3284 canvas_item->opacity = p_opacity;
3285 }
canvas_item_get_opacity(RID p_item,float p_opacity) const3286 float VisualServerRaster::canvas_item_get_opacity(RID p_item, float p_opacity) const {
3287
3288 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3289 ERR_FAIL_COND_V(!canvas_item, -1);
3290 return canvas_item->opacity;
3291 }
3292
canvas_item_set_on_top(RID p_item,bool p_on_top)3293 void VisualServerRaster::canvas_item_set_on_top(RID p_item, bool p_on_top) {
3294
3295 VS_CHANGED;
3296 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3297 ERR_FAIL_COND(!canvas_item);
3298 canvas_item->ontop = p_on_top;
3299 }
3300
canvas_item_is_on_top(RID p_item) const3301 bool VisualServerRaster::canvas_item_is_on_top(RID p_item) const {
3302 const CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3303 ERR_FAIL_COND_V(!canvas_item, false);
3304 return canvas_item->ontop;
3305 }
3306
canvas_item_set_self_opacity(RID p_item,float p_self_opacity)3307 void VisualServerRaster::canvas_item_set_self_opacity(RID p_item, float p_self_opacity) {
3308 VS_CHANGED;
3309 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3310 ERR_FAIL_COND(!canvas_item);
3311 canvas_item->self_opacity = p_self_opacity;
3312 }
canvas_item_get_self_opacity(RID p_item,float p_self_opacity) const3313 float VisualServerRaster::canvas_item_get_self_opacity(RID p_item, float p_self_opacity) const {
3314
3315 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3316 ERR_FAIL_COND_V(!canvas_item, -1);
3317 return canvas_item->self_opacity;
3318 }
3319
canvas_item_add_line(RID p_item,const Point2 & p_from,const Point2 & p_to,const Color & p_color,float p_width)3320 void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
3321 VS_CHANGED;
3322 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3323 ERR_FAIL_COND(!canvas_item);
3324
3325 CanvasItem::CommandLine *line = memnew(CanvasItem::CommandLine);
3326 ERR_FAIL_COND(!line);
3327 line->color = p_color;
3328 line->from = p_from;
3329 line->to = p_to;
3330 line->width = p_width;
3331 canvas_item->rect_dirty = true;
3332
3333 canvas_item->commands.push_back(line);
3334 }
3335
canvas_item_add_rect(RID p_item,const Rect2 & p_rect,const Color & p_color)3336 void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
3337 VS_CHANGED;
3338 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3339 ERR_FAIL_COND(!canvas_item);
3340
3341 CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
3342 ERR_FAIL_COND(!rect);
3343 rect->modulate = p_color;
3344 rect->rect = p_rect;
3345 canvas_item->rect_dirty = true;
3346
3347 canvas_item->commands.push_back(rect);
3348 }
3349
canvas_item_add_circle(RID p_item,const Point2 & p_pos,float p_radius,const Color & p_color)3350 void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
3351
3352 VS_CHANGED;
3353 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3354 ERR_FAIL_COND(!canvas_item);
3355
3356 CanvasItem::CommandCircle *circle = memnew(CanvasItem::CommandCircle);
3357 ERR_FAIL_COND(!circle);
3358 circle->color = p_color;
3359 circle->pos = p_pos;
3360 circle->radius = p_radius;
3361
3362 canvas_item->commands.push_back(circle);
3363 }
3364
canvas_item_add_texture_rect(RID p_item,const Rect2 & p_rect,RID p_texture,bool p_tile,const Color & p_modulate,bool p_transpose)3365 void VisualServerRaster::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) {
3366 VS_CHANGED;
3367 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3368 ERR_FAIL_COND(!canvas_item);
3369
3370 CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
3371 ERR_FAIL_COND(!rect);
3372 rect->modulate = p_modulate;
3373 rect->rect = p_rect;
3374 rect->flags = 0;
3375 if (p_tile) {
3376 rect->flags |= Rasterizer::CANVAS_RECT_TILE;
3377 rect->flags |= Rasterizer::CANVAS_RECT_REGION;
3378 rect->source = Rect2(0, 0, p_rect.size.width, p_rect.size.height);
3379 }
3380
3381 if (p_rect.size.x < 0) {
3382
3383 rect->flags |= Rasterizer::CANVAS_RECT_FLIP_H;
3384 rect->rect.size.x = -rect->rect.size.x;
3385 }
3386 if (p_rect.size.y < 0) {
3387
3388 rect->flags |= Rasterizer::CANVAS_RECT_FLIP_V;
3389 rect->rect.size.y = -rect->rect.size.y;
3390 }
3391 if (p_transpose) {
3392 rect->flags |= Rasterizer::CANVAS_RECT_TRANSPOSE;
3393 SWAP(rect->rect.size.x, rect->rect.size.y);
3394 }
3395 rect->texture = p_texture;
3396 canvas_item->rect_dirty = true;
3397 canvas_item->commands.push_back(rect);
3398 }
3399
canvas_item_add_texture_rect_region(RID p_item,const Rect2 & p_rect,RID p_texture,const Rect2 & p_src_rect,const Color & p_modulate,bool p_transpose)3400 void VisualServerRaster::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) {
3401 VS_CHANGED;
3402 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3403 ERR_FAIL_COND(!canvas_item);
3404
3405 CanvasItem::CommandRect *rect = memnew(CanvasItem::CommandRect);
3406 ERR_FAIL_COND(!rect);
3407 rect->modulate = p_modulate;
3408 rect->rect = p_rect;
3409 rect->texture = p_texture;
3410 rect->source = p_src_rect;
3411 rect->flags = Rasterizer::CANVAS_RECT_REGION;
3412
3413 if (p_rect.size.x < 0) {
3414
3415 rect->flags |= Rasterizer::CANVAS_RECT_FLIP_H;
3416 rect->rect.size.x = -rect->rect.size.x;
3417 }
3418 if (p_rect.size.y < 0) {
3419
3420 rect->flags |= Rasterizer::CANVAS_RECT_FLIP_V;
3421 rect->rect.size.y = -rect->rect.size.y;
3422 }
3423 if (p_transpose) {
3424 rect->flags |= Rasterizer::CANVAS_RECT_TRANSPOSE;
3425 SWAP(rect->rect.size.x, rect->rect.size.y);
3426 }
3427
3428 canvas_item->rect_dirty = true;
3429
3430 canvas_item->commands.push_back(rect);
3431 }
3432
canvas_item_add_style_box(RID p_item,const Rect2 & p_rect,const Rect2 & p_source,RID p_texture,const Vector2 & p_topleft,const Vector2 & p_bottomright,bool p_draw_center,const Color & p_modulate)3433 void VisualServerRaster::canvas_item_add_style_box(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, bool p_draw_center, const Color &p_modulate) {
3434
3435 VS_CHANGED;
3436 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3437 ERR_FAIL_COND(!canvas_item);
3438
3439 CanvasItem::CommandStyle *style = memnew(CanvasItem::CommandStyle);
3440 ERR_FAIL_COND(!style);
3441 style->texture = p_texture;
3442 style->rect = p_rect;
3443 style->source = p_source;
3444 style->draw_center = p_draw_center;
3445 style->color = p_modulate;
3446 style->margin[MARGIN_LEFT] = p_topleft.x;
3447 style->margin[MARGIN_TOP] = p_topleft.y;
3448 style->margin[MARGIN_RIGHT] = p_bottomright.x;
3449 style->margin[MARGIN_BOTTOM] = p_bottomright.y;
3450 canvas_item->rect_dirty = true;
3451
3452 canvas_item->commands.push_back(style);
3453 }
canvas_item_add_primitive(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,RID p_texture,float p_width)3454 void VisualServerRaster::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) {
3455 VS_CHANGED;
3456 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3457 ERR_FAIL_COND(!canvas_item);
3458
3459 CanvasItem::CommandPrimitive *prim = memnew(CanvasItem::CommandPrimitive);
3460 ERR_FAIL_COND(!prim);
3461 prim->texture = p_texture;
3462 prim->points = p_points;
3463 prim->uvs = p_uvs;
3464 prim->colors = p_colors;
3465 prim->width = p_width;
3466 canvas_item->rect_dirty = true;
3467
3468 canvas_item->commands.push_back(prim);
3469 }
3470
canvas_item_add_polygon(RID p_item,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,RID p_texture)3471 void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture) {
3472
3473 VS_CHANGED;
3474 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3475 ERR_FAIL_COND(!canvas_item);
3476 #ifdef DEBUG_ENABLED
3477 int pointcount = p_points.size();
3478 ERR_FAIL_COND(pointcount < 3);
3479 int color_size = p_colors.size();
3480 int uv_size = p_uvs.size();
3481 ERR_FAIL_COND(color_size != 0 && color_size != 1 && color_size != pointcount);
3482 ERR_FAIL_COND(uv_size != 0 && (uv_size != pointcount || !p_texture.is_valid()));
3483 #endif
3484 Vector<int> indices = Geometry::triangulate_polygon(p_points);
3485
3486 if (indices.empty()) {
3487
3488 ERR_EXPLAIN("Bad Polygon!");
3489 ERR_FAIL_V();
3490 }
3491
3492 CanvasItem::CommandPolygon *polygon = memnew(CanvasItem::CommandPolygon);
3493 ERR_FAIL_COND(!polygon);
3494 polygon->texture = p_texture;
3495 polygon->points = p_points;
3496 polygon->uvs = p_uvs;
3497 polygon->colors = p_colors;
3498 polygon->indices = indices;
3499 polygon->count = indices.size();
3500 canvas_item->rect_dirty = true;
3501
3502 canvas_item->commands.push_back(polygon);
3503 }
3504
canvas_item_add_triangle_array_ptr(RID p_item,int p_count,const int * p_indices,const Point2 * p_points,const Color * p_colors,const Point2 * p_uvs,RID p_texture)3505 void VisualServerRaster::canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int *p_indices, const Point2 *p_points, const Color *p_colors, const Point2 *p_uvs, RID p_texture) {
3506
3507 VS_CHANGED;
3508 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3509 ERR_FAIL_COND(!canvas_item);
3510
3511 ERR_FAIL_COND(p_count <= 0);
3512
3513 ERR_FAIL_COND(p_points == NULL);
3514
3515 CanvasItem::CommandPolygonPtr *polygon = memnew(CanvasItem::CommandPolygonPtr);
3516 ERR_FAIL_COND(!polygon);
3517 polygon->texture = p_texture;
3518 polygon->points = p_points;
3519 polygon->uvs = p_uvs;
3520 polygon->colors = p_colors;
3521 polygon->indices = p_indices;
3522 polygon->count = p_count * 3;
3523 canvas_item->rect_dirty = true;
3524
3525 canvas_item->commands.push_back(polygon);
3526 };
3527
canvas_item_add_triangle_array(RID p_item,const Vector<int> & p_indices,const Vector<Point2> & p_points,const Vector<Color> & p_colors,const Vector<Point2> & p_uvs,RID p_texture,int p_count)3528 void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, int p_count) {
3529
3530 VS_CHANGED;
3531 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3532 ERR_FAIL_COND(!canvas_item);
3533
3534 int ps = p_points.size();
3535 ERR_FAIL_COND(!p_colors.empty() && p_colors.size() != ps && p_colors.size() != 1);
3536 ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size() != ps);
3537
3538 Vector<int> indices = p_indices;
3539
3540 int count = p_count * 3;
3541
3542 if (indices.empty()) {
3543
3544 ERR_FAIL_COND(ps % 3 != 0);
3545 if (p_count == -1)
3546 count = ps;
3547 } else {
3548
3549 ERR_FAIL_COND(indices.size() % 3 != 0);
3550 if (p_count == -1)
3551 count = indices.size();
3552 }
3553
3554 CanvasItem::CommandPolygon *polygon = memnew(CanvasItem::CommandPolygon);
3555 ERR_FAIL_COND(!polygon);
3556 polygon->texture = p_texture;
3557 polygon->points = p_points;
3558 polygon->uvs = p_uvs;
3559 polygon->colors = p_colors;
3560 polygon->indices = indices;
3561 polygon->count = count;
3562 canvas_item->rect_dirty = true;
3563
3564 canvas_item->commands.push_back(polygon);
3565 }
3566
canvas_item_add_set_transform(RID p_item,const Matrix32 & p_transform)3567 void VisualServerRaster::canvas_item_add_set_transform(RID p_item, const Matrix32 &p_transform) {
3568
3569 VS_CHANGED;
3570 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3571 ERR_FAIL_COND(!canvas_item);
3572
3573 CanvasItem::CommandTransform *tr = memnew(CanvasItem::CommandTransform);
3574 ERR_FAIL_COND(!tr);
3575 tr->xform = p_transform;
3576
3577 canvas_item->commands.push_back(tr);
3578 }
3579
canvas_item_add_set_blend_mode(RID p_item,MaterialBlendMode p_blend)3580 void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend) {
3581
3582 VS_CHANGED;
3583 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3584 ERR_FAIL_COND(!canvas_item);
3585
3586 CanvasItem::CommandBlendMode *bm = memnew(CanvasItem::CommandBlendMode);
3587 ERR_FAIL_COND(!bm);
3588 bm->blend_mode = p_blend;
3589
3590 canvas_item->commands.push_back(bm);
3591 };
3592
canvas_item_set_z(RID p_item,int p_z)3593 void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z) {
3594
3595 ERR_FAIL_COND(p_z < CANVAS_ITEM_Z_MIN || p_z > CANVAS_ITEM_Z_MAX);
3596 VS_CHANGED;
3597 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3598 ERR_FAIL_COND(!canvas_item);
3599 canvas_item->z = p_z;
3600 }
3601
canvas_item_set_z_as_relative_to_parent(RID p_item,bool p_enable)3602 void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
3603
3604 VS_CHANGED;
3605 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3606 ERR_FAIL_COND(!canvas_item);
3607 canvas_item->z_relative = p_enable;
3608 }
3609
canvas_item_set_copy_to_backbuffer(RID p_item,bool p_enable,const Rect2 & p_rect)3610 void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
3611
3612 VS_CHANGED;
3613 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3614 ERR_FAIL_COND(!canvas_item);
3615 if (bool(canvas_item->copy_back_buffer != NULL) != p_enable) {
3616 if (p_enable) {
3617 canvas_item->copy_back_buffer = memnew(Rasterizer::CanvasItem::CopyBackBuffer);
3618 } else {
3619 memdelete(canvas_item->copy_back_buffer);
3620 canvas_item->copy_back_buffer = NULL;
3621 }
3622 }
3623
3624 if (p_enable) {
3625 canvas_item->copy_back_buffer->rect = p_rect;
3626 canvas_item->copy_back_buffer->full = p_rect == Rect2();
3627 }
3628 }
3629
canvas_item_set_use_parent_material(RID p_item,bool p_enable)3630 void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
3631
3632 VS_CHANGED;
3633 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3634 ERR_FAIL_COND(!canvas_item);
3635 canvas_item->use_parent_material = p_enable;
3636 }
3637
canvas_item_set_material(RID p_item,RID p_material)3638 void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material) {
3639
3640 VS_CHANGED;
3641 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3642 ERR_FAIL_COND(!canvas_item);
3643
3644 if (canvas_item->material)
3645 canvas_item->material->owners.erase(canvas_item);
3646
3647 canvas_item->material = NULL;
3648
3649 if (canvas_item_material_owner.owns(p_material)) {
3650 canvas_item->material = canvas_item_material_owner.get(p_material);
3651 canvas_item->material->owners.insert(canvas_item);
3652 }
3653 }
3654
canvas_item_set_sort_children_by_y(RID p_item,bool p_enable)3655 void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
3656
3657 VS_CHANGED;
3658 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3659 ERR_FAIL_COND(!canvas_item);
3660 canvas_item->sort_y = p_enable;
3661 }
3662
canvas_item_add_clip_ignore(RID p_item,bool p_ignore)3663 void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
3664
3665 VS_CHANGED;
3666 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3667 ERR_FAIL_COND(!canvas_item);
3668
3669 CanvasItem::CommandClipIgnore *ci = memnew(CanvasItem::CommandClipIgnore);
3670 ERR_FAIL_COND(!ci);
3671 ci->ignore = p_ignore;
3672
3673 canvas_item->commands.push_back(ci);
3674 }
3675
canvas_item_clear(RID p_item)3676 void VisualServerRaster::canvas_item_clear(RID p_item) {
3677 VS_CHANGED;
3678 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3679 ERR_FAIL_COND(!canvas_item);
3680
3681 canvas_item->clear();
3682 }
3683
canvas_item_raise(RID p_item)3684 void VisualServerRaster::canvas_item_raise(RID p_item) {
3685 VS_CHANGED;
3686 CanvasItem *canvas_item = canvas_item_owner.get(p_item);
3687 ERR_FAIL_COND(!canvas_item);
3688
3689 if (canvas_item->parent.is_valid()) {
3690
3691 if (canvas_owner.owns(canvas_item->parent)) {
3692
3693 Canvas *canvas = canvas_owner.get(canvas_item->parent);
3694 int idx = canvas->find_item(canvas_item);
3695 ERR_FAIL_COND(idx < 0);
3696 Canvas::ChildItem ci = canvas->child_items[idx];
3697 canvas->child_items.remove(idx);
3698 canvas->child_items.push_back(ci);
3699
3700 } else if (canvas_item_owner.owns(canvas_item->parent)) {
3701
3702 CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
3703 int idx = item_owner->child_items.find(canvas_item);
3704 ERR_FAIL_COND(idx < 0);
3705 item_owner->child_items.remove(idx);
3706 item_owner->child_items.push_back(canvas_item);
3707 }
3708 }
3709 }
3710
3711 /***** CANVAS LIGHT *******/
3712
canvas_light_create()3713 RID VisualServerRaster::canvas_light_create() {
3714
3715 Rasterizer::CanvasLight *clight = memnew(Rasterizer::CanvasLight);
3716 return canvas_light_owner.make_rid(clight);
3717 }
3718
canvas_light_attach_to_canvas(RID p_light,RID p_canvas)3719 void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
3720
3721 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3722 ERR_FAIL_COND(!clight);
3723
3724 if (clight->canvas.is_valid()) {
3725
3726 Canvas *canvas = canvas_owner.get(clight->canvas);
3727 canvas->lights.erase(clight);
3728 }
3729
3730 if (!canvas_owner.owns(p_canvas))
3731 p_canvas = RID();
3732 clight->canvas = p_canvas;
3733
3734 if (clight->canvas.is_valid()) {
3735
3736 Canvas *canvas = canvas_owner.get(clight->canvas);
3737 canvas->lights.insert(clight);
3738 }
3739 }
canvas_light_set_enabled(RID p_light,bool p_enabled)3740 void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled) {
3741
3742 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3743 ERR_FAIL_COND(!clight);
3744 clight->enabled = p_enabled;
3745 }
canvas_light_set_transform(RID p_light,const Matrix32 & p_transform)3746 void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32 &p_transform) {
3747
3748 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3749 ERR_FAIL_COND(!clight);
3750 clight->xform = p_transform;
3751 }
canvas_light_set_scale(RID p_light,float p_scale)3752 void VisualServerRaster::canvas_light_set_scale(RID p_light, float p_scale) {
3753
3754 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3755 ERR_FAIL_COND(!clight);
3756 clight->scale = p_scale;
3757 }
3758
canvas_light_set_texture(RID p_light,RID p_texture)3759 void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture) {
3760
3761 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3762 ERR_FAIL_COND(!clight);
3763 clight->texture = p_texture;
3764 }
canvas_light_set_texture_offset(RID p_light,const Vector2 & p_offset)3765 void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
3766
3767 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3768 ERR_FAIL_COND(!clight);
3769 clight->texture_offset = p_offset;
3770 }
canvas_light_set_color(RID p_light,const Color & p_color)3771 void VisualServerRaster::canvas_light_set_color(RID p_light, const Color &p_color) {
3772
3773 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3774 ERR_FAIL_COND(!clight);
3775 clight->color = p_color;
3776 }
canvas_light_set_height(RID p_light,float p_height)3777 void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height) {
3778
3779 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3780 ERR_FAIL_COND(!clight);
3781 clight->height = p_height;
3782 }
3783
canvas_light_set_energy(RID p_light,float p_energy)3784 void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy) {
3785
3786 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3787 ERR_FAIL_COND(!clight);
3788 clight->energy = p_energy;
3789 }
3790
canvas_light_set_z_range(RID p_light,int p_min_z,int p_max_z)3791 void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
3792
3793 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3794 ERR_FAIL_COND(!clight);
3795 clight->z_min = p_min_z;
3796 clight->z_max = p_max_z;
3797 }
3798
canvas_light_set_layer_range(RID p_light,int p_min_layer,int p_max_layer)3799 void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
3800
3801 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3802 ERR_FAIL_COND(!clight);
3803 clight->layer_min = p_min_layer;
3804 clight->layer_max = p_max_layer;
3805 }
3806
canvas_light_set_item_mask(RID p_light,int p_mask)3807 void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask) {
3808
3809 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3810 ERR_FAIL_COND(!clight);
3811 clight->item_mask = p_mask;
3812 }
3813
canvas_light_set_item_shadow_mask(RID p_light,int p_mask)3814 void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask) {
3815
3816 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3817 ERR_FAIL_COND(!clight);
3818 clight->item_shadow_mask = p_mask;
3819 }
3820
canvas_light_set_mode(RID p_light,CanvasLightMode p_mode)3821 void VisualServerRaster::canvas_light_set_mode(RID p_light, CanvasLightMode p_mode) {
3822
3823 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3824 ERR_FAIL_COND(!clight);
3825 clight->mode = p_mode;
3826 }
canvas_light_set_shadow_enabled(RID p_light,bool p_enabled)3827 void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
3828
3829 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3830 ERR_FAIL_COND(!clight);
3831
3832 if (clight->shadow_buffer.is_valid() == p_enabled)
3833 return;
3834 if (p_enabled) {
3835 clight->shadow_buffer = rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
3836 } else {
3837 rasterizer->free(clight->shadow_buffer);
3838 clight->shadow_buffer = RID();
3839 }
3840 }
3841
canvas_light_set_shadow_buffer_size(RID p_light,int p_size)3842 void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size) {
3843
3844 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3845 ERR_FAIL_COND(!clight);
3846
3847 ERR_FAIL_COND(p_size < 32 || p_size > 16384);
3848
3849 clight->shadow_buffer_size = next_power_of_2(p_size);
3850
3851 if (clight->shadow_buffer.is_valid()) {
3852 rasterizer->free(clight->shadow_buffer);
3853 clight->shadow_buffer = rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
3854 }
3855 }
3856
canvas_light_set_shadow_esm_multiplier(RID p_light,float p_multiplier)3857 void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier) {
3858
3859 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3860 ERR_FAIL_COND(!clight);
3861 clight->shadow_esm_mult = p_multiplier;
3862 }
3863
canvas_light_set_shadow_color(RID p_light,const Color & p_color)3864 void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
3865
3866 Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
3867 ERR_FAIL_COND(!clight);
3868 clight->shadow_color = p_color;
3869 }
3870
3871 /****** CANVAS LIGHT OCCLUDER ******/
3872
canvas_light_occluder_create()3873 RID VisualServerRaster::canvas_light_occluder_create() {
3874
3875 Rasterizer::CanvasLightOccluderInstance *occluder = memnew(Rasterizer::CanvasLightOccluderInstance);
3876
3877 return canvas_light_occluder_owner.make_rid(occluder);
3878 }
3879
canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas)3880 void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
3881
3882 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
3883 ERR_FAIL_COND(!occluder);
3884
3885 if (occluder->canvas.is_valid()) {
3886
3887 Canvas *canvas = canvas_owner.get(occluder->canvas);
3888 canvas->occluders.erase(occluder);
3889 }
3890
3891 if (!canvas_owner.owns(p_canvas))
3892 p_canvas = RID();
3893
3894 occluder->canvas = p_canvas;
3895
3896 if (occluder->canvas.is_valid()) {
3897
3898 Canvas *canvas = canvas_owner.get(occluder->canvas);
3899 canvas->occluders.insert(occluder);
3900 }
3901 }
3902
canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled)3903 void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
3904
3905 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
3906 ERR_FAIL_COND(!occluder);
3907
3908 occluder->enabled = p_enabled;
3909 }
3910
canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon)3911 void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
3912
3913 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
3914 ERR_FAIL_COND(!occluder);
3915
3916 if (occluder->polygon.is_valid()) {
3917 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
3918 if (occluder_poly) {
3919 occluder_poly->owners.erase(occluder);
3920 }
3921 }
3922
3923 occluder->polygon = p_polygon;
3924 occluder->polygon_buffer = RID();
3925
3926 if (occluder->polygon.is_valid()) {
3927 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
3928 if (!occluder_poly)
3929 occluder->polygon = RID();
3930 ERR_FAIL_COND(!occluder_poly);
3931 occluder_poly->owners.insert(occluder);
3932 occluder->polygon_buffer = occluder_poly->occluder;
3933 occluder->aabb_cache = occluder_poly->aabb;
3934 occluder->cull_cache = occluder_poly->cull_mode;
3935 }
3936 }
3937
canvas_light_occluder_set_transform(RID p_occluder,const Matrix32 & p_xform)3938 void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder, const Matrix32 &p_xform) {
3939
3940 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
3941 ERR_FAIL_COND(!occluder);
3942
3943 occluder->xform = p_xform;
3944 }
3945
canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask)3946 void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
3947
3948 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
3949 ERR_FAIL_COND(!occluder);
3950
3951 occluder->light_mask = p_mask;
3952 }
3953
canvas_occluder_polygon_create()3954 RID VisualServerRaster::canvas_occluder_polygon_create() {
3955
3956 CanvasLightOccluderPolygon *occluder_poly = memnew(CanvasLightOccluderPolygon);
3957 occluder_poly->occluder = rasterizer->canvas_light_occluder_create();
3958 return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
3959 }
3960
canvas_occluder_polygon_set_shape(RID p_occluder_polygon,const DVector<Vector2> & p_shape,bool p_close)3961 void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2> &p_shape, bool p_close) {
3962
3963 if (p_shape.size() < 3) {
3964 canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, p_shape);
3965 return;
3966 }
3967
3968 DVector<Vector2> lines;
3969 int lc = p_shape.size() * 2;
3970
3971 lines.resize(lc - (p_close ? 0 : 2));
3972 {
3973 DVector<Vector2>::Write w = lines.write();
3974 DVector<Vector2>::Read r = p_shape.read();
3975
3976 int max = lc / 2;
3977 if (!p_close) {
3978 max--;
3979 }
3980 for (int i = 0; i < max; i++) {
3981
3982 Vector2 a = r[i];
3983 Vector2 b = r[(i + 1) % (lc / 2)];
3984 w[i * 2 + 0] = a;
3985 w[i * 2 + 1] = b;
3986 }
3987 }
3988
3989 canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, lines);
3990 }
3991
canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2> & p_shape)3992 void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const DVector<Vector2> &p_shape) {
3993
3994 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
3995 ERR_FAIL_COND(!occluder_poly);
3996 ERR_FAIL_COND(p_shape.size() & 1);
3997
3998 int lc = p_shape.size();
3999 occluder_poly->aabb = Rect2();
4000 {
4001 DVector<Vector2>::Read r = p_shape.read();
4002 for (int i = 0; i < lc; i++) {
4003 if (i == 0)
4004 occluder_poly->aabb.pos = r[i];
4005 else
4006 occluder_poly->aabb.expand_to(r[i]);
4007 }
4008 }
4009
4010 rasterizer->canvas_light_occluder_set_polylines(occluder_poly->occluder, p_shape);
4011 for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
4012 E->get()->aabb_cache = occluder_poly->aabb;
4013 }
4014 }
4015
canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode)4016 void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, CanvasOccluderPolygonCullMode p_mode) {
4017
4018 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
4019 ERR_FAIL_COND(!occluder_poly);
4020 occluder_poly->cull_mode = p_mode;
4021 for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
4022 E->get()->cull_cache = p_mode;
4023 }
4024 }
4025
canvas_item_material_create()4026 RID VisualServerRaster::canvas_item_material_create() {
4027
4028 Rasterizer::CanvasItemMaterial *material = memnew(Rasterizer::CanvasItemMaterial);
4029 return canvas_item_material_owner.make_rid(material);
4030 }
4031
canvas_item_material_set_shader(RID p_material,RID p_shader)4032 void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader) {
4033
4034 VS_CHANGED;
4035 Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
4036 ERR_FAIL_COND(!material);
4037 material->shader = p_shader;
4038 }
canvas_item_material_set_shader_param(RID p_material,const StringName & p_param,const Variant & p_value)4039 void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName &p_param, const Variant &p_value) {
4040
4041 VS_CHANGED;
4042 Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
4043 ERR_FAIL_COND(!material);
4044 if (p_value.get_type() == Variant::NIL)
4045 material->shader_param.erase(p_param);
4046 else
4047 material->shader_param[p_param] = p_value;
4048 }
canvas_item_material_get_shader_param(RID p_material,const StringName & p_param) const4049 Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName &p_param) const {
4050 Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
4051 ERR_FAIL_COND_V(!material, Variant());
4052 if (!material->shader_param.has(p_param)) {
4053 ERR_FAIL_COND_V(!material->shader.is_valid(), Variant());
4054 return rasterizer->shader_get_default_param(material->shader, p_param);
4055 }
4056
4057 return material->shader_param[p_param];
4058 }
4059
canvas_item_material_set_shading_mode(RID p_material,CanvasItemShadingMode p_mode)4060 void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode) {
4061
4062 VS_CHANGED;
4063 Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_material);
4064 ERR_FAIL_COND(!material);
4065 material->shading_mode = p_mode;
4066 }
4067
4068 /******** CANVAS *********/
4069
black_bars_set_margins(int p_left,int p_top,int p_right,int p_bottom)4070 void VisualServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
4071
4072 black_margin[MARGIN_LEFT] = p_left;
4073 black_margin[MARGIN_TOP] = p_top;
4074 black_margin[MARGIN_RIGHT] = p_right;
4075 black_margin[MARGIN_BOTTOM] = p_bottom;
4076 }
4077
black_bars_set_images(RID p_left,RID p_top,RID p_right,RID p_bottom)4078 void VisualServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
4079
4080 black_image[MARGIN_LEFT] = p_left;
4081 black_image[MARGIN_TOP] = p_top;
4082 black_image[MARGIN_RIGHT] = p_right;
4083 black_image[MARGIN_BOTTOM] = p_bottom;
4084 }
4085
_free_attached_instances(RID p_rid,bool p_free_scenario)4086 void VisualServerRaster::_free_attached_instances(RID p_rid, bool p_free_scenario) {
4087
4088 Map<RID, Set<RID> >::Element *E = instance_dependency_map.find(p_rid);
4089
4090 if (E) {
4091 // has instances
4092 while (E->get().size()) {
4093 // erase all attached instances
4094 if (p_free_scenario)
4095 instance_set_scenario(E->get().front()->get(), RID());
4096 else
4097 instance_set_base(E->get().front()->get(), RID());
4098 }
4099 }
4100
4101 instance_dependency_map.erase(p_rid);
4102 }
4103
custom_shade_model_set_shader(int p_model,RID p_shader)4104 void VisualServerRaster::custom_shade_model_set_shader(int p_model, RID p_shader) {
4105
4106 VS_CHANGED;
4107 // rasterizer->custom_shade_model_set_shader(p_model,p_shader);
4108 }
4109
custom_shade_model_get_shader(int p_model) const4110 RID VisualServerRaster::custom_shade_model_get_shader(int p_model) const {
4111
4112 //return rasterizer->custom_shade_model_get_shader(p_model);
4113 return RID();
4114 }
custom_shade_model_set_name(int p_model,const String & p_name)4115 void VisualServerRaster::custom_shade_model_set_name(int p_model, const String &p_name) {
4116
4117 //rasterizer->custom_shade_model_set_name(p_model,p_name);
4118 }
custom_shade_model_get_name(int p_model) const4119 String VisualServerRaster::custom_shade_model_get_name(int p_model) const {
4120
4121 //return rasterizer->custom_shade_model_get_name(p_model);
4122 return "";
4123 }
custom_shade_model_set_param_info(int p_model,const List<PropertyInfo> & p_info)4124 void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info) {
4125
4126 VS_CHANGED;
4127 //rasterizer->custom_shade_model_set_param_info(p_model,p_info);
4128 }
custom_shade_model_get_param_info(int p_model,List<PropertyInfo> * p_info) const4129 void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info) const {
4130
4131 //rasterizer->custom_shade_model_get_param_info(p_model,p_info);
4132 }
4133
free(RID p_rid)4134 void VisualServerRaster::free(RID p_rid) {
4135
4136 VS_CHANGED;
4137
4138 if (rasterizer->is_texture(p_rid) || rasterizer->is_material(p_rid) || rasterizer->is_shader(p_rid) || rasterizer->is_environment(p_rid)) {
4139
4140 rasterizer->free(p_rid);
4141 } else if (rasterizer->is_skeleton(p_rid)) {
4142
4143 Map<RID, Set<Instance *> >::Element *E = skeleton_dependency_map.find(p_rid);
4144
4145 if (E) {
4146 //detach skeletons
4147 for (Set<Instance *>::Element *F = E->get().front(); F; F = F->next()) {
4148
4149 F->get()->data.skeleton = RID();
4150 }
4151 skeleton_dependency_map.erase(E);
4152 }
4153
4154 rasterizer->free(p_rid);
4155 } else if (rasterizer->is_mesh(p_rid) || rasterizer->is_multimesh(p_rid) || rasterizer->is_light(p_rid) || rasterizer->is_particles(p_rid) || rasterizer->is_immediate(p_rid)) {
4156 //delete the resource
4157
4158 _free_attached_instances(p_rid);
4159 rasterizer->free(p_rid);
4160 } else if (room_owner.owns(p_rid)) {
4161
4162 _free_attached_instances(p_rid);
4163 Room *room = room_owner.get(p_rid);
4164 ERR_FAIL_COND(!room);
4165 room_owner.free(p_rid);
4166 memdelete(room);
4167
4168 } else if (portal_owner.owns(p_rid)) {
4169
4170 _free_attached_instances(p_rid);
4171
4172 Portal *portal = portal_owner.get(p_rid);
4173 ERR_FAIL_COND(!portal);
4174 portal_owner.free(p_rid);
4175 memdelete(portal);
4176
4177 } else if (baked_light_owner.owns(p_rid)) {
4178
4179 _free_attached_instances(p_rid);
4180
4181 BakedLight *baked_light = baked_light_owner.get(p_rid);
4182 ERR_FAIL_COND(!baked_light);
4183 if (baked_light->data.octree_texture.is_valid())
4184 rasterizer->free(baked_light->data.octree_texture);
4185 baked_light_owner.free(p_rid);
4186 memdelete(baked_light);
4187
4188 } else if (baked_light_sampler_owner.owns(p_rid)) {
4189
4190 _free_attached_instances(p_rid);
4191
4192 BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get(p_rid);
4193 ERR_FAIL_COND(!baked_light_sampler);
4194 //if (baked_light->data.octree_texture.is_valid())
4195 // rasterizer->free(baked_light->data.octree_texture);
4196 baked_light_sampler_owner.free(p_rid);
4197 memdelete(baked_light_sampler);
4198
4199 } else if (camera_owner.owns(p_rid)) {
4200 // delete te camera
4201
4202 Camera *camera = camera_owner.get(p_rid);
4203 ERR_FAIL_COND(!camera);
4204
4205 camera_owner.free(p_rid);
4206 memdelete(camera);
4207
4208 } else if (viewport_owner.owns(p_rid)) {
4209 // delete the viewport
4210
4211 Viewport *viewport = viewport_owner.get(p_rid);
4212 ERR_FAIL_COND(!viewport);
4213
4214 // Viewport *parent=NULL;
4215
4216 rasterizer->free(viewport->viewport_data);
4217 if (viewport->render_target.is_valid()) {
4218
4219 rasterizer->free(viewport->render_target);
4220 }
4221
4222 if (viewport->update_list.in_list())
4223 viewport_update_list.remove(&viewport->update_list);
4224 if (screen_viewports.has(p_rid))
4225 screen_viewports.erase(p_rid);
4226
4227 while (viewport->canvas_map.size()) {
4228
4229 Canvas *c = viewport->canvas_map.front()->get().canvas;
4230 c->viewports.erase(p_rid);
4231
4232 viewport->canvas_map.erase(viewport->canvas_map.front());
4233 }
4234
4235 viewport_owner.free(p_rid);
4236 memdelete(viewport);
4237
4238 } else if (instance_owner.owns(p_rid)) {
4239 // delete the instance
4240
4241 _update_instances(); // be sure
4242
4243 Instance *instance = instance_owner.get(p_rid);
4244 ERR_FAIL_COND(!instance);
4245
4246 instance_set_room(p_rid, RID());
4247 instance_set_scenario(p_rid, RID());
4248 instance_geometry_set_baked_light(p_rid, RID());
4249 instance_geometry_set_baked_light_sampler(p_rid, RID());
4250 instance_set_base(p_rid, RID());
4251
4252 if (instance->data.skeleton.is_valid())
4253 instance_attach_skeleton(p_rid, RID());
4254
4255 instance_owner.free(p_rid);
4256 memdelete(instance);
4257
4258 } else if (canvas_owner.owns(p_rid)) {
4259
4260 Canvas *canvas = canvas_owner.get(p_rid);
4261 ERR_FAIL_COND(!canvas);
4262
4263 while (canvas->viewports.size()) {
4264
4265 Viewport *vp = viewport_owner.get(canvas->viewports.front()->get());
4266 ERR_FAIL_COND(!vp);
4267
4268 Map<RID, Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
4269 ERR_FAIL_COND(!E);
4270 vp->canvas_map.erase(p_rid);
4271
4272 canvas->viewports.erase(canvas->viewports.front());
4273 }
4274
4275 for (int i = 0; i < canvas->child_items.size(); i++) {
4276
4277 canvas->child_items[i].item->parent = RID();
4278 }
4279
4280 for (Set<Rasterizer::CanvasLight *>::Element *E = canvas->lights.front(); E; E = E->next()) {
4281
4282 E->get()->canvas = RID();
4283 }
4284
4285 for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *E = canvas->occluders.front(); E; E = E->next()) {
4286
4287 E->get()->canvas = RID();
4288 }
4289
4290 canvas_owner.free(p_rid);
4291
4292 memdelete(canvas);
4293
4294 } else if (canvas_item_owner.owns(p_rid)) {
4295
4296 CanvasItem *canvas_item = canvas_item_owner.get(p_rid);
4297 ERR_FAIL_COND(!canvas_item);
4298
4299 if (canvas_item->parent.is_valid()) {
4300
4301 if (canvas_owner.owns(canvas_item->parent)) {
4302
4303 Canvas *canvas = canvas_owner.get(canvas_item->parent);
4304 canvas->erase_item(canvas_item);
4305 } else if (canvas_item_owner.owns(canvas_item->parent)) {
4306
4307 CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
4308 item_owner->child_items.erase(canvas_item);
4309 }
4310 }
4311
4312 for (int i = 0; i < canvas_item->child_items.size(); i++) {
4313
4314 canvas_item->child_items[i]->parent = RID();
4315 }
4316
4317 if (canvas_item->material) {
4318 canvas_item->material->owners.erase(canvas_item);
4319 }
4320
4321 canvas_item_owner.free(p_rid);
4322
4323 memdelete(canvas_item);
4324
4325 } else if (canvas_item_material_owner.owns(p_rid)) {
4326
4327 Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_rid);
4328 ERR_FAIL_COND(!material);
4329 for (Set<Rasterizer::CanvasItem *>::Element *E = material->owners.front(); E; E = E->next()) {
4330
4331 E->get()->material = NULL;
4332 }
4333
4334 canvas_item_material_owner.free(p_rid);
4335 memdelete(material);
4336
4337 } else if (canvas_light_owner.owns(p_rid)) {
4338
4339 Rasterizer::CanvasLight *canvas_light = canvas_light_owner.get(p_rid);
4340 ERR_FAIL_COND(!canvas_light);
4341
4342 if (canvas_light->canvas.is_valid()) {
4343 Canvas *canvas = canvas_owner.get(canvas_light->canvas);
4344 if (canvas)
4345 canvas->lights.erase(canvas_light);
4346 }
4347
4348 if (canvas_light->shadow_buffer.is_valid())
4349 rasterizer->free(canvas_light->shadow_buffer);
4350
4351 canvas_light_owner.free(p_rid);
4352 memdelete(canvas_light);
4353
4354 } else if (canvas_light_occluder_owner.owns(p_rid)) {
4355
4356 Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_rid);
4357 ERR_FAIL_COND(!occluder);
4358
4359 if (occluder->polygon.is_valid()) {
4360
4361 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(occluder->polygon);
4362 if (occluder_poly) {
4363 occluder_poly->owners.erase(occluder);
4364 }
4365 }
4366
4367 if (occluder->canvas.is_valid() && canvas_owner.owns(occluder->canvas)) {
4368
4369 Canvas *canvas = canvas_owner.get(occluder->canvas);
4370 canvas->occluders.erase(occluder);
4371 }
4372
4373 canvas_light_occluder_owner.free(p_rid);
4374 memdelete(occluder);
4375
4376 } else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
4377
4378 CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_rid);
4379 ERR_FAIL_COND(!occluder_poly);
4380 rasterizer->free(occluder_poly->occluder);
4381
4382 while (occluder_poly->owners.size()) {
4383
4384 occluder_poly->owners.front()->get()->polygon = RID();
4385 occluder_poly->owners.erase(occluder_poly->owners.front());
4386 }
4387
4388 canvas_light_occluder_polygon_owner.free(p_rid);
4389 memdelete(occluder_poly);
4390
4391 } else if (scenario_owner.owns(p_rid)) {
4392
4393 Scenario *scenario = scenario_owner.get(p_rid);
4394 ERR_FAIL_COND(!scenario);
4395
4396 _update_instances(); // be sure
4397 _free_attached_instances(p_rid, true);
4398
4399 //rasterizer->free( scenario->environment );
4400 scenario_owner.free(p_rid);
4401 memdelete(scenario);
4402
4403 } else {
4404
4405 ERR_FAIL();
4406 }
4407 }
4408
_instance_draw(Instance * p_instance)4409 void VisualServerRaster::_instance_draw(Instance *p_instance) {
4410
4411 if (p_instance->light_cache_dirty) {
4412 int l = 0;
4413 //add positional lights
4414 InstanceSet::Element *LE = p_instance->lights.front();
4415 p_instance->data.light_instances.resize(p_instance->lights.size());
4416 while (LE) {
4417
4418 p_instance->data.light_instances[l++] = LE->get()->light_info->instance;
4419 LE = LE->next();
4420 }
4421 p_instance->light_cache_dirty = false;
4422 }
4423
4424 switch (p_instance->base_type) {
4425
4426 case INSTANCE_MESH: {
4427 rasterizer->add_mesh(p_instance->base_rid, &p_instance->data);
4428 } break;
4429 case INSTANCE_MULTIMESH: {
4430 rasterizer->add_multimesh(p_instance->base_rid, &p_instance->data);
4431 } break;
4432 case INSTANCE_IMMEDIATE: {
4433 rasterizer->add_immediate(p_instance->base_rid, &p_instance->data);
4434 } break;
4435 case INSTANCE_PARTICLES: {
4436 rasterizer->add_particles(p_instance->particles_info->instance, &p_instance->data);
4437 } break;
4438 default: {};
4439 }
4440 }
4441
_camera_generate_endpoints(Instance * p_light,Camera * p_camera,float p_range_min,float p_range_max)4442 Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max) {
4443
4444 // setup a camera matrix for that range!
4445 CameraMatrix camera_matrix;
4446
4447 switch (p_camera->type) {
4448
4449 case Camera::ORTHOGONAL: {
4450
4451 camera_matrix.set_orthogonal(p_camera->size, viewport_rect.width / (float)viewport_rect.height, p_range_min, p_range_max, p_camera->vaspect);
4452 } break;
4453 case Camera::PERSPECTIVE: {
4454
4455 camera_matrix.set_perspective(
4456 p_camera->fov,
4457 viewport_rect.width / (float)viewport_rect.height,
4458 p_range_min,
4459 p_range_max,
4460 p_camera->vaspect);
4461
4462 } break;
4463 }
4464
4465 //obtain the frustum endpoints
4466
4467 Vector<Vector3> endpoints;
4468 endpoints.resize(8);
4469 bool res = camera_matrix.get_endpoints(p_camera->transform, &endpoints[0]);
4470 ERR_FAIL_COND_V(!res, Vector<Vector3>());
4471
4472 return endpoints;
4473 }
4474
_camera_generate_orthogonal_planes(Instance * p_light,Camera * p_camera,float p_range_min,float p_range_max)4475 Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max) {
4476
4477 Vector<Vector3> endpoints = _camera_generate_endpoints(p_light, p_camera, p_range_min, p_range_max); // frustum plane endpoints
4478 ERR_FAIL_COND_V(endpoints.empty(), Vector<Plane>());
4479
4480 // obtain the light frustm ranges (given endpoints)
4481
4482 Vector3 x_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_X).normalized();
4483 Vector3 y_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Y).normalized();
4484 Vector3 z_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
4485
4486 float x_min, x_max;
4487 float y_min, y_max;
4488 float z_min, z_max;
4489
4490 for (int j = 0; j < 8; j++) {
4491
4492 float d_x = x_vec.dot(endpoints[j]);
4493 float d_y = y_vec.dot(endpoints[j]);
4494 float d_z = z_vec.dot(endpoints[j]);
4495
4496 if (j == 0 || d_x < x_min)
4497 x_min = d_x;
4498 if (j == 0 || d_x > x_max)
4499 x_max = d_x;
4500
4501 if (j == 0 || d_y < y_min)
4502 y_min = d_y;
4503 if (j == 0 || d_y > y_max)
4504 y_max = d_y;
4505
4506 if (j == 0 || d_z < z_min)
4507 z_min = d_z;
4508 if (j == 0 || d_z > z_max)
4509 z_max = d_z;
4510 }
4511 //now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
4512
4513 Vector<Plane> light_frustum_planes;
4514 light_frustum_planes.resize(6);
4515
4516 //right/left
4517 light_frustum_planes[0] = Plane(x_vec, x_max);
4518 light_frustum_planes[1] = Plane(-x_vec, -x_min);
4519 //top/bottom
4520 light_frustum_planes[2] = Plane(y_vec, y_max);
4521 light_frustum_planes[3] = Plane(-y_vec, -y_min);
4522 //near/far
4523 light_frustum_planes[4] = Plane(z_vec, z_max + 1e6);
4524 light_frustum_planes[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed
4525
4526 //TODO@ add more actual frustum planes to minimize get
4527
4528 return light_frustum_planes;
4529 }
_light_instance_update_pssm_shadow(Instance * p_light,Scenario * p_scenario,Camera * p_camera,const CullRange & p_cull_range)4530 void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
4531
4532 int splits = rasterizer->light_instance_get_shadow_passes(p_light->light_info->instance);
4533
4534 float split_weight = rasterizer->light_directional_get_shadow_param(p_light->base_rid, LIGHT_DIRECTIONAL_SHADOW_PARAM_PSSM_SPLIT_WEIGHT);
4535
4536 float distances[5];
4537 float texsize = rasterizer->light_instance_get_shadow_size(p_light->light_info->instance);
4538
4539 // float cull_min=p_cull_range.min;
4540 //float cull_max=p_cull_range.max;
4541
4542 bool overlap = rasterizer->light_instance_get_pssm_shadow_overlap(p_light->light_info->instance);
4543
4544 float cull_min = p_camera->znear;
4545 float cull_max = p_camera->zfar;
4546 float max_dist = rasterizer->light_directional_get_shadow_param(p_light->base_rid, VS::LIGHT_DIRECTIONAL_SHADOW_PARAM_MAX_DISTANCE);
4547 if (max_dist > 0.0)
4548 cull_max = MIN(cull_max, max_dist);
4549
4550 for (int i = 0; i < splits; i++) {
4551 float idm = i / (float)splits;
4552 float lg = cull_min * Math::pow(cull_max / cull_min, idm);
4553 float uniform = cull_min + (cull_max - cull_min) * idm;
4554 distances[i] = lg * split_weight + uniform * (1.0 - split_weight);
4555 }
4556
4557 distances[0] = cull_min;
4558 distances[splits] = cull_max;
4559
4560 for (int i = 0; i < splits; i++) {
4561
4562 // setup a camera matrix for that range!
4563 CameraMatrix camera_matrix;
4564
4565 switch (p_camera->type) {
4566
4567 case Camera::ORTHOGONAL: {
4568
4569 camera_matrix.set_orthogonal(
4570 p_camera->size,
4571 viewport_rect.width / (float)viewport_rect.height,
4572 distances[(i == 0 || !overlap) ? i : i - 1],
4573 distances[i + 1],
4574 p_camera->vaspect
4575
4576 );
4577 } break;
4578 case Camera::PERSPECTIVE: {
4579
4580 camera_matrix.set_perspective(
4581 p_camera->fov,
4582 viewport_rect.width / (float)viewport_rect.height,
4583 distances[(i == 0 || !overlap) ? i : i - 1],
4584 distances[i + 1],
4585 p_camera->vaspect
4586
4587 );
4588
4589 } break;
4590 }
4591
4592 //obtain the frustum endpoints
4593
4594 Vector3 endpoints[8]; // frustum plane endpoints
4595 bool res = camera_matrix.get_endpoints(p_camera->transform, endpoints);
4596 ERR_CONTINUE(!res);
4597
4598 // obtain the light frustm ranges (given endpoints)
4599
4600 Vector3 x_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_X).normalized();
4601 Vector3 y_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Y).normalized();
4602 Vector3 z_vec = p_light->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
4603 //z_vec points agsint the camera, like in default opengl
4604
4605 float x_min, x_max;
4606 float y_min, y_max;
4607 float z_min, z_max;
4608
4609 float x_min_cam, x_max_cam;
4610 float y_min_cam, y_max_cam;
4611 float z_min_cam, z_max_cam;
4612
4613 //used for culling
4614 for (int j = 0; j < 8; j++) {
4615
4616 float d_x = x_vec.dot(endpoints[j]);
4617 float d_y = y_vec.dot(endpoints[j]);
4618 float d_z = z_vec.dot(endpoints[j]);
4619
4620 if (j == 0 || d_x < x_min)
4621 x_min = d_x;
4622 if (j == 0 || d_x > x_max)
4623 x_max = d_x;
4624
4625 if (j == 0 || d_y < y_min)
4626 y_min = d_y;
4627 if (j == 0 || d_y > y_max)
4628 y_max = d_y;
4629
4630 if (j == 0 || d_z < z_min)
4631 z_min = d_z;
4632 if (j == 0 || d_z > z_max)
4633 z_max = d_z;
4634 }
4635
4636 {
4637 //camera viewport stuff
4638 //this trick here is what stabilizes the shadow (make potential jaggies to not move)
4639 //at the cost of some wasted resolution. Still the quality increase is very well worth it
4640
4641 Vector3 center;
4642
4643 for (int j = 0; j < 8; j++) {
4644
4645 center += endpoints[j];
4646 }
4647 center /= 8.0;
4648
4649 //center=x_vec*(x_max-x_min)*0.5 + y_vec*(y_max-y_min)*0.5 + z_vec*(z_max-z_min)*0.5;
4650
4651 float radius = 0;
4652
4653 for (int j = 0; j < 8; j++) {
4654
4655 float d = center.distance_to(endpoints[j]);
4656 if (d > radius)
4657 radius = d;
4658 }
4659
4660 radius *= texsize / (texsize - 2.0); //add a texel by each side, so stepified texture will always fit
4661
4662 x_max_cam = x_vec.dot(center) + radius;
4663 x_min_cam = x_vec.dot(center) - radius;
4664 y_max_cam = y_vec.dot(center) + radius;
4665 y_min_cam = y_vec.dot(center) - radius;
4666 z_max_cam = z_vec.dot(center) + radius;
4667 z_min_cam = z_vec.dot(center) - radius;
4668
4669 float unit = radius * 2.0 / texsize;
4670
4671 x_max_cam = Math::stepify(x_max_cam, unit);
4672 x_min_cam = Math::stepify(x_min_cam, unit);
4673 y_max_cam = Math::stepify(y_max_cam, unit);
4674 y_min_cam = Math::stepify(y_min_cam, unit);
4675 }
4676
4677 //now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
4678
4679 Vector<Plane> light_frustum_planes;
4680 light_frustum_planes.resize(6);
4681
4682 //right/left
4683 light_frustum_planes[0] = Plane(x_vec, x_max);
4684 light_frustum_planes[1] = Plane(-x_vec, -x_min);
4685 //top/bottom
4686 light_frustum_planes[2] = Plane(y_vec, y_max);
4687 light_frustum_planes[3] = Plane(-y_vec, -y_min);
4688 //near/far
4689 light_frustum_planes[4] = Plane(z_vec, z_max + 1e6);
4690 light_frustum_planes[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed
4691
4692 int caster_cull_count = p_scenario->octree.cull_convex(light_frustum_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
4693
4694 // a pre pass will need to be needed to determine the actual z-near to be used
4695 for (int j = 0; j < caster_cull_count; j++) {
4696
4697 float min, max;
4698 Instance *ins = instance_shadow_cull_result[j];
4699 if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
4700 continue;
4701 ins->transformed_aabb.project_range_in_plane(Plane(z_vec, 0), min, max);
4702
4703 if (max > z_max)
4704 z_max = max;
4705 }
4706
4707 {
4708 CameraMatrix ortho_camera;
4709 real_t half_x = (x_max_cam - x_min_cam) * 0.5;
4710 real_t half_y = (y_max_cam - y_min_cam) * 0.5;
4711
4712 ortho_camera.set_orthogonal(-half_x, half_x, -half_y, half_y, 0, (z_max - z_min_cam));
4713
4714 Transform ortho_transform;
4715 ortho_transform.basis = p_light->data.transform.basis;
4716 ortho_transform.origin = x_vec * (x_min_cam + half_x) + y_vec * (y_min_cam + half_y) + z_vec * z_max;
4717
4718 rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, i, ortho_camera, ortho_transform, distances[i], distances[i + 1]);
4719 }
4720
4721 rasterizer->begin_shadow_map(p_light->light_info->instance, i);
4722
4723 for (int j = 0; j < caster_cull_count; j++) {
4724
4725 Instance *instance = instance_shadow_cull_result[j];
4726 if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
4727 continue;
4728 _instance_draw(instance);
4729 }
4730
4731 rasterizer->end_shadow_map();
4732 }
4733 }
4734
_lispm_look(const Vector3 pos,const Vector3 dir,const Vector3 up)4735 CameraMatrix _lispm_look(const Vector3 pos, const Vector3 dir, const Vector3 up) {
4736
4737 Vector3 dirN;
4738 Vector3 upN;
4739 Vector3 lftN;
4740
4741 lftN = dir.cross(up);
4742 lftN.normalize();
4743
4744 upN = lftN.cross(dir);
4745 upN.normalize();
4746 dirN = dir.normalized();
4747
4748 CameraMatrix cmout;
4749 float *output = &cmout.matrix[0][0];
4750 output[0] = lftN[0];
4751 output[1] = upN[0];
4752 output[2] = -dirN[0];
4753 output[3] = 0.0;
4754
4755 output[4] = lftN[1];
4756 output[5] = upN[1];
4757 output[6] = -dirN[1];
4758 output[7] = 0.0;
4759
4760 output[8] = lftN[2];
4761 output[9] = upN[2];
4762 output[10] = -dirN[2];
4763 output[11] = 0.0;
4764
4765 output[12] = -lftN.dot(pos);
4766 output[13] = -upN.dot(pos);
4767 output[14] = dirN.dot(pos);
4768 output[15] = 1.0;
4769
4770 return cmout;
4771 }
4772
4773 #if 1
4774
_light_instance_update_lispsm_shadow(Instance * p_light,Scenario * p_scenario,Camera * p_camera,const CullRange & p_cull_range)4775 void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
4776
4777 Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
4778 Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
4779
4780 float near_dist = 1;
4781
4782 Vector<Plane> light_frustum_planes = _camera_generate_orthogonal_planes(p_light, p_camera, p_cull_range.min, p_cull_range.max);
4783 int caster_count = p_scenario->octree.cull_convex(light_frustum_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
4784
4785 // this could be faster by just getting supports from the AABBs..
4786 // but, safer to do as the original implementation explains for now..
4787
4788 Vector<Vector3> caster_pointcloud;
4789 caster_pointcloud.resize(caster_count * 8);
4790 int caster_pointcloud_size = 0;
4791
4792 {
4793
4794 //fill pointcloud
4795 Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
4796
4797 for (int i = 0; i < caster_count; i++) {
4798
4799 Instance *ins = instance_shadow_cull_result[i];
4800 if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
4801 continue;
4802
4803 for (int j = 0; j < 8; j++) {
4804
4805 Vector3 v = ins->aabb.get_endpoint(j);
4806 v = ins->data.transform.xform(v);
4807 caster_pointcloud_ptr[caster_pointcloud_size + j] = v;
4808 }
4809
4810 caster_pointcloud_size += 8;
4811 }
4812 }
4813
4814 // now generate a pointcloud that contains the maximum bound (camera extruded by light)
4815
4816 Vector<Vector3> camera_pointcloud = _camera_generate_endpoints(p_light, p_camera, p_cull_range.min, p_cull_range.max);
4817 int cpcsize = camera_pointcloud.size();
4818 camera_pointcloud.resize(cpcsize * 2);
4819
4820 for (int i = 0; i < cpcsize; i++) {
4821
4822 camera_pointcloud[i + cpcsize] = camera_pointcloud[i] - light_vec * 1000;
4823 }
4824
4825 // Vector<Vector3> frustum_points=_camera_generate_endpoints(p_light,p_camera,p_cull_range.min,p_cull_range.max);
4826
4827 // compute the "light-space" basis, using the algorithm described in the paper
4828 // note: since bodyB is defined in eye space, all of these vectors should also be defined in eye space
4829
4830 Vector3 eye = p_camera->transform.origin;
4831 Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
4832
4833 CameraMatrix light_space_basis = _lispm_look(eye, light_vec, up);
4834
4835 AABB light_space_aabb;
4836
4837 { //create an optimal AABB from both the camera pointcloud and the objects pointcloud
4838 AABB light_space_pointcloud_aabb;
4839 AABB light_space_camera_aabb;
4840 //xform pointcloud
4841 const Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
4842
4843 for (int i = 0; i < caster_pointcloud_size; i++) {
4844
4845 Vector3 p = light_space_basis.xform(caster_pointcloud_ptr[i]);
4846 if (i == 0) {
4847 light_space_pointcloud_aabb.pos = p;
4848 } else {
4849 light_space_pointcloud_aabb.expand_to(p);
4850 }
4851 }
4852 for (int i = 0; i < camera_pointcloud.size(); i++) {
4853
4854 Vector3 p = light_space_basis.xform(camera_pointcloud[i]);
4855 if (i == 0) {
4856 light_space_camera_aabb.pos = p;
4857 } else {
4858 light_space_camera_aabb.expand_to(p);
4859 }
4860 }
4861
4862 light_space_aabb = light_space_pointcloud_aabb.intersection(light_space_camera_aabb);
4863 }
4864
4865 float lvdp = light_vec.dot(view_vec);
4866
4867 float sin_gamma = Math::sqrt(1.0 - lvdp * lvdp);
4868 //use the formulas of the paper to get n (and f)
4869 float factor = 1.0 / sin_gamma;
4870 float z_n = factor * near_dist; //often 1
4871 float d = Math::abs(light_space_aabb.size.y); //perspective transform depth //light space y extents
4872 float z_f = z_n + d * sin_gamma;
4873 float n = (z_n + Math::sqrt(z_f * z_n)) / sin_gamma;
4874 float f = n + d;
4875
4876 Vector3 pos = eye - up * (n - near_dist);
4877
4878 CameraMatrix light_space_basis2 = _lispm_look(pos, light_vec, up);
4879 //Transform light_space_basis2;
4880 //light_space_basis2.set_look_at(pos,light_vec-pos,up);
4881 //light_space_basis2.affine_invert();
4882
4883 //one possibility for a simple perspective transformation matrix
4884 //with the two parameters n(near) and f(far) in y direction
4885
4886 CameraMatrix lisp_matrix;
4887 lisp_matrix.matrix[1][1] = (f + n) / (f - n);
4888 lisp_matrix.matrix[3][1] = -2 * f * n / (f - n);
4889 lisp_matrix.matrix[1][3] = 1;
4890 lisp_matrix.matrix[3][3] = 0;
4891
4892 CameraMatrix projection = lisp_matrix * light_space_basis2;
4893 //CameraMatrix projection = light_space_basis2 * lisp_matrix;
4894
4895 AABB proj_space_aabb;
4896
4897 {
4898
4899 AABB proj_space_pointcloud_aabb;
4900 AABB proj_space_camera_aabb;
4901 //xform pointcloud
4902 Vector3 *caster_pointcloud_ptr = &caster_pointcloud[0];
4903 for (int i = 0; i < caster_pointcloud_size; i++) {
4904
4905 Vector3 p = projection.xform(caster_pointcloud_ptr[i]);
4906 if (i == 0) {
4907 proj_space_pointcloud_aabb.pos = p;
4908 } else {
4909 proj_space_pointcloud_aabb.expand_to(p);
4910 }
4911 }
4912
4913 for (int i = 0; i < camera_pointcloud.size(); i++) {
4914
4915 Vector3 p = projection.xform(camera_pointcloud[i]);
4916 if (i == 0) {
4917 proj_space_camera_aabb.pos = p;
4918 } else {
4919 proj_space_camera_aabb.expand_to(p);
4920 }
4921 }
4922
4923 //proj_space_aabb=proj_space_pointcloud_aabb.intersection_with(proj_space_camera_aabb);
4924 proj_space_aabb = proj_space_pointcloud_aabb;
4925 }
4926
4927 projection.scale_translate_to_fit(proj_space_aabb);
4928 projection = projection * lisp_matrix;
4929
4930 CameraMatrix scale;
4931 scale.make_scale(Vector3(1.0, 1.0, -1.0)); // transform to left handed
4932
4933 projection = scale * projection;
4934
4935 rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, projection, light_space_basis2.inverse());
4936
4937 rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
4938
4939 for (int i = 0; i < caster_count; i++) {
4940
4941 Instance *instance = instance_shadow_cull_result[i];
4942
4943 if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
4944 continue;
4945 _instance_draw(instance);
4946 }
4947
4948 rasterizer->end_shadow_map();
4949 }
4950
4951 #else
4952
_light_instance_update_lispsm_shadow(Instance * p_light,Scenario * p_scenario,Camera * p_camera,const CullRange & p_cull_range)4953 void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
4954
4955 /* STEP 1: GENERATE LIGHT TRANSFORM */
4956
4957 Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
4958 Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
4959 float viewdot = Math::absf(light_vec.dot(view_vec));
4960
4961 Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
4962
4963 Transform light_transform;
4964 light_transform.set_look_at(Vector3(), light_vec, up);
4965
4966 /* STEP 2: GENERATE WORDLSPACE PLANES AND VECTORS*/
4967 float range_min = 0.01; //p_cull_range.min
4968 float range_max = 20; //p_cull_range.max;
4969
4970 Vector<Vector3> camera_endpoints = _camera_generate_endpoints(p_light, p_camera, range_min, range_max); // frustum plane endpoints
4971 ERR_FAIL_COND(camera_endpoints.empty());
4972
4973 // obtain the light frustm ranges (given endpoints)
4974
4975 Vector3 light_x_vec = light_transform.basis.get_axis(Vector3::AXIS_X).normalized();
4976 Vector3 light_y_vec = light_transform.basis.get_axis(Vector3::AXIS_Y).normalized();
4977 Vector3 light_z_vec = light_transform.basis.get_axis(Vector3::AXIS_Z).normalized();
4978
4979 Vector3 light_axis_max;
4980 Vector3 light_axis_min;
4981
4982 for (int j = 0; j < 8; j++) {
4983
4984 float d_x = light_x_vec.dot(camera_endpoints[j]);
4985 float d_y = light_y_vec.dot(camera_endpoints[j]);
4986 float d_z = light_z_vec.dot(camera_endpoints[j]);
4987
4988 if (j == 0 || d_x < light_axis_min.x)
4989 light_axis_min.x = d_x;
4990 if (j == 0 || d_x > light_axis_max.x)
4991 light_axis_max.x = d_x;
4992
4993 if (j == 0 || d_y < light_axis_min.y)
4994 light_axis_min.y = d_y;
4995 if (j == 0 || d_y > light_axis_max.y)
4996 light_axis_max.y = d_y;
4997
4998 if (j == 0 || d_z < light_axis_min.z)
4999 light_axis_min.z = d_z;
5000 if (j == 0 || d_z > light_axis_max.z)
5001 light_axis_max.z = d_z;
5002 }
5003
5004 //now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
5005
5006 Vector<Plane> light_cull_planes;
5007 light_cull_planes.resize(6);
5008
5009 //right/left
5010 light_cull_planes[0] = Plane(light_x_vec, light_axis_max.x);
5011 light_cull_planes[1] = Plane(-light_x_vec, -light_axis_min.x);
5012 //top/bottom
5013 light_cull_planes[2] = Plane(light_y_vec, light_axis_max.y);
5014 light_cull_planes[3] = Plane(-light_y_vec, -light_axis_min.y);
5015 //near/far
5016 light_cull_planes[4] = Plane(light_z_vec, light_axis_max.z + 1e6);
5017 light_cull_planes[5] = Plane(-light_z_vec, -light_axis_min.z); // z_min is ok, since casters further than far-light plane are not needed
5018
5019 /* STEP 3: CULL CASTERS */
5020
5021 int caster_count = p_scenario->octree.cull_convex(light_cull_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
5022
5023 /* STEP 4: ADJUST FAR Z PLANE */
5024
5025 float caster_max_z = 1e-1;
5026 for (int i = 0; i < caster_count; i++) {
5027
5028 Instance *ins = instance_shadow_cull_result[i];
5029 if (!ins->visible || ins->cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
5030 continue;
5031
5032 //@TODO optimize using support mapping
5033 for (int j = 0; j < 8; j++) {
5034
5035 Vector3 v = ins->data.transform.xform(ins->aabb.get_endpoint(j));
5036 float d = light_z_vec.dot(v);
5037 if (d > caster_max_z)
5038 caster_max_z = d;
5039 }
5040 }
5041
5042 float expand = caster_max_z - light_axis_max.z;
5043 if (expand < 0)
5044 expand = 0;
5045 light_axis_max.z = MAX(caster_max_z, light_axis_max.z);
5046
5047 /* STEP 5: CREATE ORTHOGONAL PROJECTION */
5048
5049 CameraMatrix light_projection;
5050
5051 real_t half_x = (light_axis_max.x - light_axis_min.x) * 0.5;
5052 real_t half_y = (light_axis_max.y - light_axis_min.y) * 0.5;
5053 light_projection.set_orthogonal(-half_x, half_x, half_y, -half_y, 0, (light_axis_max.z - light_axis_min.z));
5054 light_transform.origin = light_x_vec * (light_axis_min.x + half_x) + light_y_vec * (light_axis_min.y + half_y) + light_z_vec * light_axis_max.z;
5055
5056 if (/*false &&*/ viewdot < 0.96) {
5057
5058 float lvdp = light_vec.dot(view_vec);
5059
5060 float near_dist = 1.0;
5061 float sin_gamma = Math::sqrt(1.0 - lvdp * lvdp);
5062 //use the formulas of the paper to get n (and f)
5063 float factor = 1.0 / sin_gamma;
5064 float z_n = factor * near_dist; //often 1
5065 float d = Math::abs(light_axis_max.y - light_axis_min.y); //perspective transform depth //light space y extents
5066 float z_f = z_n + d * sin_gamma;
5067 float n = (z_n + Math::sqrt(z_f * z_n)) / sin_gamma;
5068 float f = n + d;
5069
5070 CameraMatrix lisp_matrix;
5071 lisp_matrix.matrix[1][1] = (f + n) / (f - n);
5072 lisp_matrix.matrix[3][1] = -2 * f * n / (f - n);
5073 lisp_matrix.matrix[1][3] = 1;
5074 lisp_matrix.matrix[3][3] = 0;
5075
5076 Vector3 pos = p_camera->transform.origin - up * (n - near_dist);
5077
5078 CameraMatrix world2light = _lispm_look(pos, light_vec, up);
5079 CameraMatrix projection = lisp_matrix * world2light;
5080
5081 AABB projection_bounds;
5082 for (int i = 0; i < camera_endpoints.size(); i++) {
5083
5084 Vector3 p = camera_endpoints[i];
5085 if (i == 0)
5086 projection_bounds.pos = projection.xform(p);
5087 else
5088 projection_bounds.expand_to(projection.xform(p));
5089
5090 projection_bounds.expand_to(projection.xform(p + light_vec * -expand));
5091 }
5092
5093 CameraMatrix scaletrans;
5094 scaletrans.scale_translate_to_fit(projection_bounds);
5095 projection = scaletrans * lisp_matrix;
5096
5097 CameraMatrix scale;
5098 scale.make_scale(Vector3(1.0, 1.0, -1.0)); // transform to left handed
5099
5100 projection = scale * projection;
5101
5102 rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, projection, world2light.inverse(), viewdot);
5103
5104 } else {
5105 //orthogonal
5106 rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, 0, light_projection, light_transform, viewdot);
5107 }
5108
5109 rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
5110
5111 for (int i = 0; i < caster_count; i++) {
5112
5113 Instance *instance = instance_shadow_cull_result[i];
5114
5115 if (!instance->visible || instance->cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
5116 continue;
5117 _instance_draw(instance);
5118 }
5119
5120 rasterizer->end_shadow_map();
5121 }
5122
5123 #endif
5124
_light_instance_update_shadow(Instance * p_light,Scenario * p_scenario,Camera * p_camera,const CullRange & p_cull_range)5125 void VisualServerRaster::_light_instance_update_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range) {
5126
5127 if (!rasterizer->shadow_allocate_near(p_light->light_info->instance))
5128 return; // shadow could not be updated
5129
5130 /* VisualServerRaster supports for many shadow techniques, using the one the rasterizer requests */
5131
5132 Rasterizer::ShadowType shadow_type = rasterizer->light_instance_get_shadow_type(p_light->light_info->instance);
5133
5134 switch (shadow_type) {
5135
5136 case Rasterizer::SHADOW_SIMPLE: {
5137 /* SPOT SHADOW */
5138
5139 rasterizer->begin_shadow_map(p_light->light_info->instance, 0);
5140
5141 //using this one ensures that raster deferred will have it
5142
5143 float far = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
5144
5145 float angle = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_SPOT_ANGLE);
5146
5147 CameraMatrix cm;
5148 cm.set_perspective(angle * 2.0, 1.0, 0.001, far);
5149
5150 Vector<Plane> planes = cm.get_projection_planes(p_light->data.transform);
5151 int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
5152
5153 for (int i = 0; i < cull_count; i++) {
5154
5155 Instance *instance = instance_shadow_cull_result[i];
5156 if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
5157 continue;
5158 _instance_draw(instance);
5159 }
5160
5161 rasterizer->end_shadow_map();
5162
5163 } break;
5164 case Rasterizer::SHADOW_DUAL_PARABOLOID: {
5165
5166 /* OMNI SHADOW */
5167
5168 int passes = rasterizer->light_instance_get_shadow_passes(p_light->light_info->instance);
5169
5170 if (passes == 2) {
5171
5172 for (int i = 0; i < 2; i++) {
5173
5174 rasterizer->begin_shadow_map(p_light->light_info->instance, i);
5175
5176 //using this one ensures that raster deferred will have it
5177
5178 float radius = rasterizer->light_get_var(p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
5179
5180 float z = i == 0 ? -1 : 1;
5181 Vector<Plane> planes;
5182 planes.resize(5);
5183 planes[0] = p_light->data.transform.xform(Plane(Vector3(0, 0, z), radius));
5184 planes[1] = p_light->data.transform.xform(Plane(Vector3(1, 0, z).normalized(), radius));
5185 planes[2] = p_light->data.transform.xform(Plane(Vector3(-1, 0, z).normalized(), radius));
5186 planes[3] = p_light->data.transform.xform(Plane(Vector3(0, 1, z).normalized(), radius));
5187 planes[4] = p_light->data.transform.xform(Plane(Vector3(0, -1, z).normalized(), radius));
5188
5189 int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, INSTANCE_GEOMETRY_MASK);
5190
5191 for (int j = 0; j < cull_count; j++) {
5192
5193 Instance *instance = instance_shadow_cull_result[j];
5194 if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
5195 continue;
5196
5197 _instance_draw(instance);
5198 }
5199
5200 rasterizer->end_shadow_map();
5201 }
5202 } else if (passes == 1) {
5203 //one go
5204 }
5205
5206 } break;
5207 case Rasterizer::SHADOW_CUBE: {
5208
5209 // todo
5210 } break;
5211 case Rasterizer::SHADOW_ORTHOGONAL: {
5212
5213 _light_instance_update_pssm_shadow(p_light, p_scenario, p_camera, p_cull_range);
5214 } break;
5215 case Rasterizer::SHADOW_PSSM: {
5216
5217 _light_instance_update_pssm_shadow(p_light, p_scenario, p_camera, p_cull_range);
5218 } break;
5219 case Rasterizer::SHADOW_PSM: {
5220
5221 _light_instance_update_lispsm_shadow(p_light, p_scenario, p_camera, p_cull_range);
5222 // todo
5223 } break;
5224 default: {}
5225 }
5226 }
5227
_portal_disconnect(Instance * p_portal,bool p_cleanup)5228 void VisualServerRaster::_portal_disconnect(Instance *p_portal, bool p_cleanup) {
5229
5230 if (p_portal->portal_info->connected) {
5231
5232 //disconnect first
5233 p_portal->portal_info->connected->portal_info->connected = NULL;
5234 p_portal->portal_info->connected = NULL;
5235 }
5236
5237 if (p_portal->room && p_portal->room->room) {
5238
5239 if (p_cleanup) {
5240
5241 p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
5242 //p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
5243 } else {
5244 p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
5245 }
5246 }
5247 }
5248
_instance_validate_autorooms(Instance * p_geometry)5249 void VisualServerRaster::_instance_validate_autorooms(Instance *p_geometry) {
5250
5251 if (p_geometry->auto_rooms.size() == 0)
5252 return;
5253
5254 p_geometry->valid_auto_rooms.clear();
5255
5256 int point_count = aabb_random_points.size();
5257 const Vector3 *src_points = &aabb_random_points[0];
5258
5259 for (Set<Instance *>::Element *E = p_geometry->valid_auto_rooms.front(); E; E = E->next()) {
5260
5261 Instance *room = E->get();
5262 Vector3 *dst_points = &transformed_aabb_random_points[0];
5263
5264 //generate points
5265 for (int i = 0; i < point_count; i++) {
5266
5267 dst_points[i] = room->room_info->affine_inverse.xform(p_geometry->data.transform.xform((src_points[i] * p_geometry->transformed_aabb.size) + p_geometry->transformed_aabb.pos));
5268 }
5269
5270 int pass = room->room_info->room->bounds.get_points_inside(dst_points, point_count);
5271
5272 float ratio = pass;
5273 if (point_count != 0) {
5274 ratio /= (float)point_count;
5275 }
5276
5277 if (ratio > 0.5) // should make some constant
5278 p_geometry->valid_auto_rooms.insert(room);
5279 }
5280 }
5281
_portal_attempt_connect(Instance * p_portal)5282 void VisualServerRaster::_portal_attempt_connect(Instance *p_portal) {
5283
5284 _portal_disconnect(p_portal);
5285
5286 Vector3 A_norm = p_portal->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
5287 Plane A_plane(p_portal->data.transform.origin, A_norm);
5288 float A_surface = p_portal->portal_info->portal->bounds.get_area();
5289 if (A_surface == 0)
5290 return; //wtf
5291
5292 Instance *found = NULL;
5293 Transform affine_inverse = p_portal->data.transform.affine_inverse();
5294
5295 for (Set<Instance *>::Element *E = p_portal->portal_info->candidate_set.front(); E; E = E->next()) {
5296
5297 Instance *B = E->get();
5298
5299 if (B->portal_info->connected)
5300 continue; // in use
5301
5302 Vector3 B_norm = B->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
5303
5304 // check that they are in front of another
5305 float dot = A_norm.dot(-B_norm);
5306
5307 if (dot < 0.707) // 45 degrees, TODO unharcode this
5308 continue;
5309
5310 // check the max distance to the other portal
5311
5312 bool valid = true;
5313
5314 Rect2 local_bounds;
5315
5316 for (int i = 0; i < B->portal_info->portal->shape.size(); i++) {
5317
5318 Point2 point2 = B->portal_info->portal->shape[i];
5319
5320 Vector3 point = B->data.transform.xform(Vector3(point2.x, point2.y, 0));
5321
5322 float dist = Math::abs(A_plane.distance_to(point));
5323
5324 if (
5325 dist > p_portal->portal_info->portal->connect_range ||
5326 dist > B->portal_info->portal->connect_range) {
5327 valid = false;
5328 break;
5329 }
5330
5331 Vector3 point_local = affine_inverse.xform(A_plane.project(point));
5332 point2 = Point2(point_local.x, point_local.y);
5333
5334 if (i == 0)
5335 local_bounds.pos = point2;
5336 else
5337 local_bounds.expand_to(point2);
5338 }
5339
5340 if (!valid)
5341 continue;
5342
5343 float B_surface = B->portal_info->portal->bounds.get_area();
5344 if (B_surface == 0)
5345 continue; //wtf
5346
5347 float clip_area = p_portal->portal_info->portal->bounds.clip(local_bounds).get_area();
5348
5349 //check that most of the area is shared
5350
5351 if ((clip_area / A_surface) < 0.5 || (clip_area / B_surface) < 0.5) // TODO change for something else
5352 continue;
5353
5354 found = B;
5355 break;
5356 }
5357
5358 if (!found) {
5359
5360 if (p_portal->room && p_portal->room->room) {
5361
5362 p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
5363 }
5364
5365 return;
5366 }
5367
5368 p_portal->portal_info->connected = found;
5369 found->portal_info->connected = p_portal;
5370 }
5371
instance_pair(void * p_self,OctreeElementID,Instance * p_A,int,OctreeElementID,Instance * p_B,int)5372 void *VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
5373
5374 VisualServerRaster *self = (VisualServerRaster *)p_self;
5375 Instance *A = p_A;
5376 Instance *B = p_B;
5377
5378 if (A->base_type == INSTANCE_PORTAL) {
5379
5380 ERR_FAIL_COND_V(B->base_type != INSTANCE_PORTAL, NULL);
5381
5382 A->portal_info->candidate_set.insert(B);
5383 B->portal_info->candidate_set.insert(A);
5384
5385 self->_portal_attempt_connect(A);
5386 //attempt to conncet portal A (will go through B anyway)
5387 //this is a little hackish, but works fine in practice
5388
5389 } else if (A->base_type == INSTANCE_BAKED_LIGHT || B->base_type == INSTANCE_BAKED_LIGHT) {
5390
5391 if (B->base_type == INSTANCE_BAKED_LIGHT) {
5392 SWAP(A, B);
5393 }
5394
5395 ERR_FAIL_COND_V(B->base_type != INSTANCE_BAKED_LIGHT_SAMPLER, NULL);
5396 B->baked_light_sampler_info->baked_lights.insert(A);
5397
5398 } else if (A->base_type == INSTANCE_ROOM || B->base_type == INSTANCE_ROOM) {
5399
5400 if (B->base_type == INSTANCE_ROOM)
5401 SWAP(A, B);
5402
5403 ERR_FAIL_COND_V(!((1 << B->base_type) & INSTANCE_GEOMETRY_MASK), NULL);
5404
5405 B->auto_rooms.insert(A);
5406 A->room_info->owned_autoroom_geometry.insert(B);
5407
5408 self->_instance_validate_autorooms(B);
5409
5410 } else {
5411
5412 if (B->base_type == INSTANCE_LIGHT) {
5413
5414 SWAP(A, B);
5415 } else if (A->base_type != INSTANCE_LIGHT) {
5416 return NULL;
5417 }
5418
5419 A->light_info->affected.insert(B);
5420 B->lights.insert(A);
5421 B->light_cache_dirty = true;
5422 }
5423
5424 return NULL;
5425 }
instance_unpair(void * p_self,OctreeElementID,Instance * p_A,int,OctreeElementID,Instance * p_B,int,void *)5426 void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *) {
5427
5428 VisualServerRaster *self = (VisualServerRaster *)p_self;
5429 Instance *A = p_A;
5430 Instance *B = p_B;
5431
5432 if (A->base_type == INSTANCE_PORTAL) {
5433
5434 ERR_FAIL_COND(B->base_type != INSTANCE_PORTAL);
5435
5436 A->portal_info->candidate_set.erase(B);
5437 B->portal_info->candidate_set.erase(A);
5438
5439 //after disconnecting them, see if they can connect again
5440 self->_portal_attempt_connect(A);
5441 self->_portal_attempt_connect(B);
5442
5443 } else if (A->base_type == INSTANCE_BAKED_LIGHT || B->base_type == INSTANCE_BAKED_LIGHT) {
5444
5445 if (B->base_type == INSTANCE_BAKED_LIGHT) {
5446 SWAP(A, B);
5447 }
5448
5449 ERR_FAIL_COND(B->base_type != INSTANCE_BAKED_LIGHT_SAMPLER);
5450 B->baked_light_sampler_info->baked_lights.erase(A);
5451
5452 } else if (A->base_type == INSTANCE_ROOM || B->base_type == INSTANCE_ROOM) {
5453
5454 if (B->base_type == INSTANCE_ROOM)
5455 SWAP(A, B);
5456
5457 ERR_FAIL_COND(!((1 << B->base_type) & INSTANCE_GEOMETRY_MASK));
5458
5459 B->auto_rooms.erase(A);
5460 B->valid_auto_rooms.erase(A);
5461 A->room_info->owned_autoroom_geometry.erase(B);
5462
5463 } else {
5464
5465 if (B->base_type == INSTANCE_LIGHT) {
5466
5467 SWAP(A, B);
5468 } else if (A->base_type != INSTANCE_LIGHT) {
5469 return;
5470 }
5471
5472 A->light_info->affected.erase(B);
5473 B->lights.erase(A);
5474 B->light_cache_dirty = true;
5475 }
5476 }
5477
_test_portal_cull(Camera * p_camera,Instance * p_from_portal,Instance * p_to_portal)5478 bool VisualServerRaster::_test_portal_cull(Camera *p_camera, Instance *p_from_portal, Instance *p_to_portal) {
5479
5480 int src_point_count = p_from_portal->portal_info->transformed_point_cache.size();
5481 int dst_point_count = p_to_portal->portal_info->transformed_point_cache.size();
5482
5483 if (src_point_count < 2 || dst_point_count < 2)
5484 return false;
5485
5486 const Vector3 *src_points = &p_from_portal->portal_info->transformed_point_cache[0];
5487 const Vector3 *dst_points = &p_to_portal->portal_info->transformed_point_cache[0];
5488
5489 bool outside = false;
5490
5491 bool clockwise = !p_from_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin);
5492
5493 for (int i = 0; i < src_point_count; i++) {
5494
5495 const Vector3 &point_prev = src_points[i ? (i - 1) : (src_point_count - 1)];
5496 const Vector3 &point = src_points[i];
5497
5498 Plane p = clockwise ? Plane(p_camera->transform.origin, point, point_prev) : Plane(p_camera->transform.origin, point_prev, point);
5499
5500 bool all_over = true;
5501
5502 for (int j = 0; j < dst_point_count; j++) {
5503
5504 if (!p.is_point_over(dst_points[j])) {
5505
5506 all_over = false;
5507 break;
5508 }
5509 }
5510
5511 if (all_over) {
5512 outside = true;
5513 break;
5514 }
5515 }
5516
5517 return !outside;
5518 }
5519
_cull_portal(Camera * p_camera,Instance * p_portal,Instance * p_from_portal)5520 void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal, Instance *p_from_portal) {
5521
5522 ERR_FAIL_COND(!p_portal->scenario); //scenario outside
5523
5524 Instance *portal = p_portal;
5525
5526 if (!portal->room) {
5527
5528 return; //portals need all to belong to a room, it may be unconfigured yet
5529 } else if (portal->last_render_pass != render_pass) {
5530
5531 return; //invalid portal, ignore
5532 } else if (portal->portal_info->last_visited_pass == render_pass) {
5533
5534 return; //portal already visited
5535 } else if (portal == p_from_portal) {
5536
5537 return; // came from this portal, don't even bother testing
5538 }
5539
5540 /* TEST DISABLE DISTANCE */
5541
5542 float disable_distance = p_portal->portal_info->portal->disable_distance;
5543 if (disable_distance) {
5544 //has disable distance..
5545 float distance = p_camera->transform.origin.distance_to(portal->data.transform.origin);
5546 if (disable_distance < distance) {
5547
5548 return;
5549 }
5550 }
5551
5552 /* TEST PORTAL NOT FACING OPTIMIZATION */
5553
5554 if (p_portal->portal_info->connected) {
5555 //connected portal means, it must face against the camera to be seen
5556 if (p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
5557
5558 return;
5559 }
5560 } else {
5561 //disconencted portals (go from room to parent room or exterior) must face towards the canera
5562 if (!p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
5563
5564 return;
5565 }
5566 }
5567
5568 if (p_from_portal && !_test_portal_cull(p_camera, p_from_portal, portal)) {
5569 return; // portal not visible (culled)
5570 }
5571
5572 portal->portal_info->last_visited_pass = render_pass;
5573
5574 if (portal->portal_info->connected) {
5575
5576 //interior<->interior portal
5577 Instance *to_room = portal->portal_info->connected->room;
5578 if (!to_room) {
5579 return; //wtf.. oh well, connected to a roomless (invalid) portal
5580 }
5581
5582 _cull_room(p_camera, to_room, portal->portal_info->connected);
5583
5584 } else {
5585 //to exterior/to parent roomportal
5586
5587 Instance *parent_room = portal->room->room;
5588
5589 _cull_room(p_camera, parent_room, portal);
5590 }
5591 }
5592
_cull_room(Camera * p_camera,Instance * p_room,Instance * p_from_portal)5593 void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room, Instance *p_from_portal) {
5594
5595 if (p_room == NULL) {
5596 //exterior
5597 exterior_visited = true;
5598
5599 for (int i = 0; i < exterior_portal_cull_count; i++) {
5600
5601 _cull_portal(p_camera, exterior_portal_cull_result[i], p_from_portal);
5602 }
5603
5604 } else {
5605
5606 ERR_FAIL_COND(!p_room->scenario);
5607
5608 if (p_room->last_render_pass != render_pass)
5609 return; //this room is invalid
5610
5611 //interior
5612 //first of all, validate the room
5613 p_room->room_info->last_visited_pass = render_pass;
5614 //see about going around portals
5615 if (!p_room->room_info->room->occlude_exterior)
5616 exterior_visited = true;
5617
5618 for (List<Instance *>::Element *E = p_room->room_info->owned_portal_instances.front(); E; E = E->next()) {
5619
5620 _cull_portal(p_camera, E->get(), p_from_portal);
5621 }
5622
5623 for (Set<Instance *>::Element *E = p_room->room_info->disconnected_child_portals.front(); E; E = E->next()) {
5624
5625 _cull_portal(p_camera, E->get(), p_from_portal);
5626 }
5627 }
5628 }
5629
_process_sampled_light(const Transform & p_camera,Instance * p_sampled_light,bool p_linear_colorspace)5630 void VisualServerRaster::_process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace) {
5631
5632 BakedLightSampler *sampler_opts = p_sampled_light->baked_light_sampler_info->sampler;
5633 int res = sampler_opts->resolution;
5634 int dp_size = res * res * 2;
5635 Color *dp_map = (Color *)alloca(sizeof(Color) * dp_size); //allocate the dual parabolloid colors
5636 Vector3 *dp_normals = (Vector3 *)alloca(sizeof(Vector3) * dp_size); //allocate the dual parabolloid normals
5637 const Vector3 *dp_src_normals = p_sampled_light->baked_light_sampler_info->sampler->dp_cache.ptr();
5638
5639 if (!p_sampled_light->baked_light_sampler_info->sampled_light.is_valid() || p_sampled_light->baked_light_sampler_info->resolution != sampler_opts->resolution) {
5640 if (p_sampled_light->baked_light_sampler_info->sampled_light.is_valid()) {
5641 rasterizer->free(p_sampled_light->baked_light_sampler_info->sampled_light);
5642 }
5643
5644 p_sampled_light->baked_light_sampler_info->resolution = sampler_opts->resolution;
5645 p_sampled_light->baked_light_sampler_info->sampled_light = rasterizer->sampled_light_dp_create(sampler_opts->resolution, sampler_opts->resolution * 2);
5646 }
5647
5648 zeromem(dp_map, sizeof(Color) * dp_size);
5649 bool valid = false;
5650 int samples = 0;
5651
5652 for (Set<Instance *>::Element *E = p_sampled_light->baked_light_sampler_info->baked_lights.front(); E; E = E->next()) {
5653
5654 Instance *bl = E->get();
5655 if (bl->baked_light_info->baked_light->sampler.size() == 0)
5656 continue; //not usable
5657
5658 Matrix3 norm_xform = bl->baked_light_info->affine_inverse.basis; //.inverse();
5659 for (int i = 0; i < dp_size; i++) {
5660 dp_normals[i] = norm_xform.xform(dp_src_normals[i]).normalized();
5661 }
5662
5663 //normals in place
5664
5665 //sample octree
5666
5667 float r = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
5668 float att = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_ATTENUATION];
5669 float str = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_STRENGTH];
5670 Vector3 s = p_sampled_light->data.transform.basis.get_scale();
5671
5672 r *= MAX(MAX(s.x, s.y), s.z);
5673 AABB sample_aabb = bl->data.transform.affine_inverse().xform(AABB(Vector3(-r, -r, -r) + p_sampled_light->data.transform.origin, Vector3(r * 2, r * 2, r * 2)));
5674 //ok got octree local AABB
5675
5676 DVector<int>::Read rp = bl->baked_light_info->baked_light->sampler.read();
5677 const int *rptr = rp.ptr();
5678
5679 int first = rptr[1];
5680 int depth = rptr[2];
5681 bool islinear = rptr[3] & 1;
5682 depth += 1;
5683
5684 AABB aabb;
5685 aabb.pos.x = decode_float((const uint8_t *)&rptr[4]);
5686 aabb.pos.y = decode_float((const uint8_t *)&rptr[5]);
5687 aabb.pos.z = decode_float((const uint8_t *)&rptr[6]);
5688 aabb.size.x = decode_float((const uint8_t *)&rptr[7]);
5689 aabb.size.y = decode_float((const uint8_t *)&rptr[8]);
5690 aabb.size.z = decode_float((const uint8_t *)&rptr[9]);
5691
5692 uint32_t *stack = (uint32_t *)alloca(depth * sizeof(uint32_t));
5693 int *stack_ptr = (int *)alloca(depth * sizeof(int));
5694 AABB *aabb_stack = (AABB *)alloca(depth * sizeof(AABB));
5695
5696 stack[0] = 0;
5697 stack_ptr[0] = first;
5698 aabb_stack[0] = aabb;
5699 Vector3 center = sample_aabb.pos + sample_aabb.size * 0.5;
5700
5701 int stack_pos = 0;
5702 Color max_col;
5703
5704 //int reso = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO];
5705
5706 int lalimit = sample_aabb.get_longest_axis_index();
5707 float limit = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO] * sample_aabb.size[lalimit];
5708
5709 while (true) {
5710
5711 bool leaf = (rptr[stack_ptr[stack_pos]] >> 16) == 0;
5712
5713 if (aabb_stack[stack_pos].size[lalimit] < limit) {
5714 leaf = true;
5715 }
5716
5717 if (leaf) {
5718
5719 Vector3 from = aabb_stack[stack_pos].pos + aabb_stack[stack_pos].size * 0.5;
5720 Vector3 norm = (from - center).normalized();
5721
5722 Color col;
5723 col.r = ((rptr[stack_ptr[stack_pos]] & 0xFFFF) / 256.0);
5724 col.g = ((rptr[stack_ptr[stack_pos] + 1] >> 16) / 256.0);
5725 col.b = ((rptr[stack_ptr[stack_pos] + 1] & 0xFFFF) / 256.0);
5726
5727 max_col.r = MAX(max_col.r, col.r);
5728 max_col.g = MAX(max_col.g, col.g);
5729 max_col.b = MAX(max_col.b, col.b);
5730
5731 if (!islinear && p_linear_colorspace) {
5732 col = col.to_linear();
5733 }
5734
5735 float distance;
5736
5737 if (aabb_stack[stack_pos].has_point(center)) {
5738 distance = 0;
5739 } else {
5740
5741 Vector3 support = aabb_stack[stack_pos].get_support(norm);
5742 distance = Math::absf(norm.dot(support) - norm.dot(center));
5743 }
5744
5745 if (distance > r)
5746 distance = r;
5747
5748 float mult = Math::pow(1.0 - distance / r, att) * str;
5749 if (mult > 0) {
5750 col.r *= mult;
5751 col.g *= mult;
5752 col.b *= mult;
5753
5754 for (int i = 0; i < dp_size; i++) {
5755 float mult2 = norm.dot(dp_normals[i]);
5756 if (mult2 < 0)
5757 mult2 = 0;
5758 Color col2(col.r * mult2, col.g * mult2, col.b * mult2, 1.0);
5759 dp_map[i].r = MAX(dp_map[i].r, col2.r);
5760 dp_map[i].g = MAX(dp_map[i].g, col2.g);
5761 dp_map[i].b = MAX(dp_map[i].b, col2.b);
5762 }
5763 }
5764
5765 samples++;
5766 //nothing is valid unless you hit a leaf
5767 valid = true;
5768 stack_pos--;
5769 } else if ((stack[stack_pos] & 0xFF) < 8) {
5770
5771 int i = stack[stack_pos] & 0xFF;
5772 int base = (stack[stack_pos] >> 8);
5773
5774 if (!((rptr[stack_ptr[stack_pos]] >> 16) & (1 << i))) {
5775 //no bit, no test
5776 stack[stack_pos] = (base << 8) + (i + 1);
5777 continue;
5778 }
5779
5780 stack[stack_pos] = ((base + 1) << 8) + (i + 1);
5781
5782 AABB child_aabb = aabb_stack[stack_pos];
5783 child_aabb.size *= 0.5;
5784 if (i & 1)
5785 child_aabb.pos.x += child_aabb.size.x;
5786 if (i & 2)
5787 child_aabb.pos.y += child_aabb.size.y;
5788 if (i & 4)
5789 child_aabb.pos.z += child_aabb.size.z;
5790
5791 if (!child_aabb.intersects(sample_aabb)) {
5792 continue;
5793 }
5794
5795 if (child_aabb.encloses(sample_aabb)) {
5796 stack[stack_pos] = (base << 8) | 8; //don't test the rest
5797 }
5798
5799 stack_pos++;
5800 ERR_FAIL_COND(stack_pos >= depth);
5801
5802 stack[stack_pos] = 0;
5803 stack_ptr[stack_pos] = rptr[stack_ptr[stack_pos - 1] + 2 + base];
5804 aabb_stack[stack_pos] = child_aabb;
5805 } else {
5806 stack_pos--;
5807 if (stack_pos < 0)
5808 break;
5809 }
5810 }
5811 }
5812
5813 //print_line("samples "+itos(samples) );
5814
5815 if (valid) {
5816
5817 for (int i = 0; i < res; i++) {
5818 //average seams to avoid aliasing
5819 {
5820 //top
5821 int ofs1 = i;
5822 int ofs2 = dp_size - res + i;
5823 Color avg(
5824 (dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
5825 (dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
5826 (dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
5827 1.0);
5828 dp_map[ofs1] = avg;
5829 dp_map[ofs2] = avg;
5830 }
5831 {
5832 //bottom
5833 int ofs1 = res * res - res + i;
5834 int ofs2 = res * res + i;
5835 Color avg(
5836 (dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
5837 (dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
5838 (dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
5839 1.0);
5840 dp_map[ofs1] = avg;
5841 dp_map[ofs2] = avg;
5842 }
5843 {
5844 //left
5845 int ofs1 = i * res;
5846 int ofs2 = res * res + (res - i - 1) * res;
5847 Color avg(
5848 (dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
5849 (dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
5850 (dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
5851 1.0);
5852 dp_map[ofs1] = avg;
5853 dp_map[ofs2] = avg;
5854 }
5855 {
5856 //right
5857 int ofs1 = i * res + (res - 1);
5858 int ofs2 = res * res + (res - i - 1) * res + (res - 1);
5859 Color avg(
5860 (dp_map[ofs1].r + dp_map[ofs2].r) * 0.5,
5861 (dp_map[ofs1].g + dp_map[ofs2].g) * 0.5,
5862 (dp_map[ofs1].b + dp_map[ofs2].b) * 0.5,
5863 1.0);
5864 dp_map[ofs1] = avg;
5865 dp_map[ofs2] = avg;
5866 }
5867 }
5868
5869 rasterizer->sampled_light_dp_update(p_sampled_light->baked_light_sampler_info->sampled_light, dp_map, 1.0);
5870 for (Set<Instance *>::Element *F = p_sampled_light->baked_light_sampler_info->owned_instances.front(); F; F = F->next()) {
5871
5872 F->get()->data.sampled_light = p_sampled_light->baked_light_sampler_info->sampled_light;
5873 }
5874
5875 } else {
5876
5877 for (Set<Instance *>::Element *F = p_sampled_light->baked_light_sampler_info->owned_instances.front(); F; F = F->next()) {
5878
5879 F->get()->data.sampled_light = RID(); //do not use because nothing close
5880 }
5881 }
5882
5883 /*
5884 highp vec3 vtx = vertex_interp;
5885 vtx.z*=dual_paraboloid.y; //side to affect
5886 vtx.z+=0.01;
5887 dp_clip=vtx.z;
5888 highp float len=length( vtx );
5889 vtx=normalize(vtx);
5890 vtx.xy/=1.0+vtx.z;
5891 vtx.z = len*dual_paraboloid.x; // it's a reciprocal(len - z_near) / (z_far - z_near);
5892 vtx+=normalize(vtx)*0.025;
5893 vtx.z = vtx.z * 2.0 - 1.0; // fit to clipspace
5894 vertex_interp=vtx;
5895 */
5896 }
5897
_render_no_camera(Viewport * p_viewport,Camera * p_camera,Scenario * p_scenario)5898 void VisualServerRaster::_render_no_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario) {
5899 RID environment;
5900 if (p_scenario->environment.is_valid())
5901 environment = p_scenario->environment;
5902 else
5903 environment = p_scenario->fallback_environment;
5904
5905 rasterizer->set_camera(Transform(), CameraMatrix(), false);
5906 rasterizer->begin_scene(p_viewport->viewport_data, environment, p_scenario->debug);
5907 rasterizer->set_viewport(viewport_rect);
5908 rasterizer->end_scene();
5909 }
5910
_render_camera(Viewport * p_viewport,Camera * p_camera,Scenario * p_scenario)5911 void VisualServerRaster::_render_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario) {
5912
5913 render_pass++;
5914 uint32_t camera_layer_mask = p_camera->visible_layers;
5915
5916 /* STEP 1 - SETUP CAMERA */
5917 CameraMatrix camera_matrix;
5918 bool ortho = false;
5919
5920 switch (p_camera->type) {
5921 case Camera::ORTHOGONAL: {
5922
5923 camera_matrix.set_orthogonal(
5924 p_camera->size,
5925 viewport_rect.width / (float)viewport_rect.height,
5926 p_camera->znear,
5927 p_camera->zfar,
5928 p_camera->vaspect
5929
5930 );
5931 ortho = true;
5932 } break;
5933 case Camera::PERSPECTIVE: {
5934
5935 camera_matrix.set_perspective(
5936 p_camera->fov,
5937 viewport_rect.width / (float)viewport_rect.height,
5938 p_camera->znear,
5939 p_camera->zfar,
5940 p_camera->vaspect
5941
5942 );
5943 ortho = false;
5944
5945 } break;
5946 }
5947
5948 rasterizer->set_camera(p_camera->transform, camera_matrix, ortho);
5949
5950 Vector<Plane> planes = camera_matrix.get_projection_planes(p_camera->transform);
5951
5952 CullRange cull_range; // cull range is used for PSSM, and having an idea of the rendering depth
5953 cull_range.nearp = Plane(p_camera->transform.origin, -p_camera->transform.basis.get_axis(2).normalized());
5954 cull_range.z_near = camera_matrix.get_z_near();
5955 cull_range.z_far = camera_matrix.get_z_far();
5956 cull_range.min = cull_range.z_far;
5957 cull_range.max = cull_range.z_near;
5958
5959 /* STEP 2 - CULL */
5960 int cull_count = p_scenario->octree.cull_convex(planes, instance_cull_result, MAX_INSTANCE_CULL);
5961 light_cull_count = 0;
5962 light_samplers_culled = 0;
5963
5964 /* print_line("OT: "+rtos( (OS::get_singleton()->get_ticks_usec()-t)/1000.0));
5965 print_line("OTO: "+itos(p_scenario->octree.get_octant_count()));
5966 // print_line("OTE: "+itos(p_scenario->octree.get_elem_count()));
5967 print_line("OTP: "+itos(p_scenario->octree.get_pair_count()));
5968 */
5969
5970 /* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
5971
5972 // compute portals
5973
5974 exterior_visited = false;
5975 exterior_portal_cull_count = 0;
5976
5977 if (room_cull_enabled) {
5978 for (int i = 0; i < cull_count; i++) {
5979
5980 Instance *ins = instance_cull_result[i];
5981 ins->last_render_pass = render_pass;
5982
5983 if (ins->base_type != INSTANCE_PORTAL)
5984 continue;
5985
5986 if (ins->room)
5987 continue;
5988
5989 ERR_CONTINUE(exterior_portal_cull_count >= MAX_EXTERIOR_PORTALS);
5990 exterior_portal_cull_result[exterior_portal_cull_count++] = ins;
5991 }
5992
5993 room_cull_count = p_scenario->octree.cull_point(p_camera->transform.origin, room_cull_result, MAX_ROOM_CULL, NULL, (1 << INSTANCE_ROOM) | (1 << INSTANCE_PORTAL));
5994
5995 Set<Instance *> current_rooms;
5996 Set<Instance *> portal_rooms;
5997 //add to set
5998 for (int i = 0; i < room_cull_count; i++) {
5999
6000 if (room_cull_result[i]->base_type == INSTANCE_ROOM) {
6001 current_rooms.insert(room_cull_result[i]);
6002 }
6003 if (room_cull_result[i]->base_type == INSTANCE_PORTAL) {
6004 //assume inside that room if also inside the portal..
6005 if (room_cull_result[i]->room) {
6006 portal_rooms.insert(room_cull_result[i]->room);
6007 }
6008
6009 SWAP(room_cull_result[i], room_cull_result[room_cull_count - 1]);
6010 room_cull_count--;
6011 i--;
6012 }
6013 }
6014
6015 //remove from set if it has a parent room or BSP doesn't contain
6016 for (int i = 0; i < room_cull_count; i++) {
6017 Instance *r = room_cull_result[i];
6018
6019 //check inside BSP
6020 Vector3 room_local_point = r->room_info->affine_inverse.xform(p_camera->transform.origin);
6021
6022 if (!portal_rooms.has(r) && !r->room_info->room->bounds.point_is_inside(room_local_point)) {
6023
6024 current_rooms.erase(r);
6025 continue;
6026 }
6027
6028 //check parent
6029 while (r->room) { // has parent room
6030
6031 current_rooms.erase(r);
6032 r = r->room;
6033 }
6034 }
6035
6036 if (current_rooms.size()) {
6037 //camera is inside a room
6038 // go through rooms
6039 for (Set<Instance *>::Element *E = current_rooms.front(); E; E = E->next()) {
6040 _cull_room(p_camera, E->get());
6041 }
6042
6043 } else {
6044 //start from exterior
6045 _cull_room(p_camera, NULL);
6046 }
6047 }
6048
6049 /* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
6050
6051 for (int i = 0; i < cull_count; i++) {
6052
6053 Instance *ins = instance_cull_result[i];
6054
6055 bool keep = false;
6056
6057 if ((camera_layer_mask & ins->layer_mask) == 0) {
6058
6059 //failure
6060 } else if (ins->base_type == INSTANCE_LIGHT) {
6061
6062 if (light_cull_count < MAX_LIGHTS_CULLED) {
6063 light_cull_result[light_cull_count++] = ins;
6064 // rasterizer->light_instance_set_active_hint(ins->light_info->instance);
6065 {
6066 //compute distance to camera using aabb support
6067 Vector3 n = ins->data.transform.basis.xform_inv(cull_range.nearp.normal).normalized();
6068 Vector3 s = ins->data.transform.xform(ins->aabb.get_support(n));
6069 ins->light_info->dtc = cull_range.nearp.distance_to(s);
6070 }
6071 }
6072
6073 } else if ((1 << ins->base_type) & INSTANCE_GEOMETRY_MASK && ins->visible && ins->data.cast_shadows != VS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
6074
6075 bool discarded = false;
6076
6077 if (ins->draw_range_end > 0) {
6078
6079 float d = cull_range.nearp.distance_to(ins->data.transform.origin);
6080 if (d < 0)
6081 d = 0;
6082 discarded = (d < ins->draw_range_begin || d >= ins->draw_range_end);
6083 }
6084
6085 if (!discarded) {
6086
6087 // test if this geometry should be visible
6088
6089 if (room_cull_enabled) {
6090
6091 if (ins->visible_in_all_rooms) {
6092 keep = true;
6093 } else if (ins->room) {
6094
6095 if (ins->room->room_info->last_visited_pass == render_pass)
6096 keep = true;
6097 } else if (ins->auto_rooms.size()) {
6098
6099 for (Set<Instance *>::Element *E = ins->auto_rooms.front(); E; E = E->next()) {
6100
6101 if (E->get()->room_info->last_visited_pass == render_pass) {
6102 keep = true;
6103 break;
6104 }
6105 }
6106 } else if (exterior_visited)
6107 keep = true;
6108 } else {
6109
6110 keep = true;
6111 }
6112 }
6113
6114 if (keep) {
6115 // update cull range
6116 float min, max;
6117 ins->transformed_aabb.project_range_in_plane(cull_range.nearp, min, max);
6118
6119 if (min < cull_range.min)
6120 cull_range.min = min;
6121 if (max > cull_range.max)
6122 cull_range.max = max;
6123
6124 if (ins->sampled_light && ins->sampled_light->baked_light_sampler_info->last_pass != render_pass) {
6125 if (light_samplers_culled < MAX_LIGHT_SAMPLERS) {
6126 light_sampler_cull_result[light_samplers_culled++] = ins->sampled_light;
6127 ins->sampled_light->baked_light_sampler_info->last_pass = render_pass;
6128 }
6129 }
6130 }
6131 }
6132
6133 if (!keep) {
6134 // remove, no reason to keep
6135 cull_count--;
6136 SWAP(instance_cull_result[i], instance_cull_result[cull_count]);
6137 i--;
6138 ins->last_render_pass = 0; // make invalid
6139 } else {
6140
6141 ins->last_render_pass = render_pass;
6142 }
6143 }
6144
6145 if (cull_range.max > cull_range.z_far)
6146 cull_range.max = cull_range.z_far;
6147 if (cull_range.min < cull_range.z_near)
6148 cull_range.min = cull_range.z_near;
6149
6150 /* STEP 5 - PROCESS LIGHTS */
6151
6152 rasterizer->shadow_clear_near(); //clear near shadows, will be recreated
6153
6154 // directional lights
6155 {
6156 List<RID>::Element *E = p_scenario->directional_lights.front();
6157
6158 while (E) {
6159
6160 Instance *light = E->get().is_valid() ? instance_owner.get(E->get()) : NULL;
6161
6162 if (light && light->light_info->enabled && rasterizer->light_has_shadow(light->base_rid)) {
6163 //rasterizer->light_instance_set_active_hint(light->light_info->instance);
6164 _light_instance_update_shadow(light, p_scenario, p_camera, cull_range);
6165 }
6166
6167 E = E->next();
6168 }
6169 }
6170
6171 //discard lights not affecting anything (useful for deferred rendering, shadowmaps, etc)
6172
6173 for (int i = 0; i < light_cull_count; i++) {
6174
6175 Instance *ins = light_cull_result[i];
6176
6177 if (light_discard_enabled) {
6178
6179 //see if the light should be pre discarded because no one is seeing it
6180 //this test may seem expensive, but in reality, it shouldn't be
6181 //because of early out condition. It will only go through everything
6182 //if it's being discarded.
6183
6184 bool valid = false;
6185 InstanceSet::Element *E = ins->light_info->affected.front();
6186 while (E) {
6187
6188 if (E->get()->last_render_pass == render_pass) {
6189
6190 valid = true; // early out.
6191 break;
6192 }
6193 E = E->next();
6194 }
6195 if (!valid) {
6196
6197 light_cull_count--;
6198 SWAP(light_cull_result[i], light_cull_result[light_cull_count]);
6199 i--;
6200 }
6201 }
6202 }
6203
6204 { //this should eventually change to
6205 //assign shadows by distance to camera
6206 SortArray<Instance *, _InstanceLightsort> sorter;
6207 sorter.sort(light_cull_result, light_cull_count);
6208 for (int i = 0; i < light_cull_count; i++) {
6209
6210 Instance *ins = light_cull_result[i];
6211
6212 if (!rasterizer->light_has_shadow(ins->base_rid) || !shadows_enabled)
6213 continue;
6214
6215 /* for far shadows?
6216 if (ins->version == ins->light_info->last_version && rasterizer->light_instance_has_far_shadow(ins->light_info->instance))
6217 continue; // didn't change
6218 */
6219
6220 _light_instance_update_shadow(ins, p_scenario, p_camera, cull_range);
6221 ins->light_info->last_version = ins->version;
6222 }
6223 }
6224
6225 /* ENVIRONMENT */
6226
6227 RID environment;
6228 if (p_camera->env.is_valid()) //camera has more environment priority
6229 environment = p_camera->env;
6230 else if (p_scenario->environment.is_valid())
6231 environment = p_scenario->environment;
6232 else
6233 environment = p_scenario->fallback_environment;
6234
6235 /* STEP 6 - SAMPLE BAKED LIGHT */
6236
6237 bool islinear = false;
6238 if (environment.is_valid()) {
6239 islinear = rasterizer->environment_is_fx_enabled(environment, VS::ENV_FX_SRGB);
6240 }
6241
6242 for (int i = 0; i < light_samplers_culled; i++) {
6243
6244 _process_sampled_light(p_camera->transform, light_sampler_cull_result[i], islinear);
6245 }
6246
6247 /* STEP 7 - PROCESS GEOMETRY AND DRAW SCENE*/
6248
6249 rasterizer->begin_scene(p_viewport->viewport_data, environment, p_scenario->debug);
6250 rasterizer->set_viewport(viewport_rect);
6251
6252 // add lights
6253
6254 {
6255 List<RID>::Element *E = p_scenario->directional_lights.front();
6256
6257 for (; E; E = E->next()) {
6258 Instance *light = E->get().is_valid() ? instance_owner.get(E->get()) : NULL;
6259
6260 ERR_CONTINUE(!light);
6261 if (!light->light_info->enabled)
6262 continue;
6263
6264 rasterizer->add_light(light->light_info->instance);
6265 light->light_info->last_add_pass = render_pass;
6266 }
6267
6268 for (int i = 0; i < light_cull_count; i++) {
6269
6270 Instance *ins = light_cull_result[i];
6271 rasterizer->add_light(ins->light_info->instance);
6272 ins->light_info->last_add_pass = render_pass;
6273 }
6274 }
6275 // add geometry
6276
6277 for (int i = 0; i < cull_count; i++) {
6278
6279 Instance *ins = instance_cull_result[i];
6280
6281 ERR_CONTINUE(!((1 << ins->base_type) & INSTANCE_GEOMETRY_MASK));
6282
6283 _instance_draw(ins);
6284 }
6285
6286 rasterizer->end_scene();
6287 }
6288
_render_canvas_item_tree(CanvasItem * p_canvas_item,const Matrix32 & p_transform,const Rect2 & p_clip_rect,const Color & p_modulate,Rasterizer::CanvasLight * p_lights)6289 void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights) {
6290
6291 static const int z_range = CANVAS_ITEM_Z_MAX - CANVAS_ITEM_Z_MIN + 1;
6292 Rasterizer::CanvasItem *z_list[z_range];
6293 Rasterizer::CanvasItem *z_last_list[z_range];
6294
6295 for (int i = 0; i < z_range; i++) {
6296 z_list[i] = NULL;
6297 z_last_list[i] = NULL;
6298 }
6299
6300 _render_canvas_item(p_canvas_item, p_transform, p_clip_rect, 1.0, 0, z_list, z_last_list, NULL, NULL);
6301
6302 for (int i = 0; i < z_range; i++) {
6303 if (!z_list[i])
6304 continue;
6305 rasterizer->canvas_render_items(z_list[i], CANVAS_ITEM_Z_MIN + i, p_modulate, p_lights);
6306 }
6307 }
6308
_render_canvas_item_viewport(VisualServer * p_self,void * p_vp,const Rect2 & p_rect)6309 void VisualServerRaster::_render_canvas_item_viewport(VisualServer *p_self, void *p_vp, const Rect2 &p_rect) {
6310
6311 VisualServerRaster *self = (VisualServerRaster *)(p_self);
6312 Viewport *vp = (Viewport *)p_vp;
6313 self->_draw_viewport(vp, p_rect.pos.x, p_rect.pos.y, p_rect.size.x, p_rect.size.y);
6314 self->rasterizer->canvas_begin();
6315 }
6316
_render_canvas_item(CanvasItem * p_canvas_item,const Matrix32 & p_transform,const Rect2 & p_clip_rect,float p_opacity,int p_z,Rasterizer::CanvasItem ** z_list,Rasterizer::CanvasItem ** z_last_list,CanvasItem * p_canvas_clip,CanvasItem * p_material_owner)6317 void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner) {
6318
6319 CanvasItem *ci = p_canvas_item;
6320
6321 if (!ci->visible)
6322 return;
6323
6324 if (p_opacity < 0.007)
6325 return;
6326
6327 Rect2 rect = ci->get_rect();
6328 Matrix32 xform = p_transform * ci->xform;
6329 Rect2 global_rect = xform.xform(rect);
6330 global_rect.pos += p_clip_rect.pos;
6331
6332 if (global_rect.intersects(p_clip_rect) && ci->viewport.is_valid() && viewport_owner.owns(ci->viewport)) {
6333
6334 Viewport *vp = viewport_owner.get(ci->viewport);
6335
6336 Point2i from = xform.get_origin() + Point2(viewport_rect.x, viewport_rect.y);
6337 Point2i size = rect.size;
6338 size.x *= xform[0].length();
6339 size.y *= xform[1].length();
6340
6341 ci->vp_render = memnew(Rasterizer::CanvasItem::ViewportRender);
6342 ci->vp_render->owner = this;
6343 ci->vp_render->udata = vp;
6344 ci->vp_render->rect = Rect2(from.x,
6345 from.y,
6346 size.x,
6347 size.y);
6348 /*
6349 _draw_viewport(vp,
6350 from.x,
6351 from.y,
6352 size.x,
6353 size.y);
6354 */
6355 //rasterizer->canvas_begin();
6356 } else {
6357 ci->vp_render = NULL;
6358 }
6359
6360 if (ci->use_parent_material && p_material_owner)
6361 ci->material_owner = p_material_owner;
6362 else {
6363 p_material_owner = ci;
6364 ci->material_owner = NULL;
6365 }
6366
6367 float opacity = ci->opacity * p_opacity;
6368
6369 int child_item_count = ci->child_items.size();
6370 CanvasItem **child_items = (CanvasItem **)alloca(child_item_count * sizeof(CanvasItem *));
6371 copymem(child_items, ci->child_items.ptr(), child_item_count * sizeof(CanvasItem *));
6372
6373 if (ci->clip) {
6374 if (p_canvas_clip != NULL) {
6375 ci->final_clip_rect = p_canvas_clip->final_clip_rect.clip(global_rect);
6376 } else {
6377 ci->final_clip_rect = global_rect;
6378 }
6379 ci->final_clip_owner = ci;
6380
6381 } else {
6382 ci->final_clip_owner = p_canvas_clip;
6383 }
6384
6385 if (ci->sort_y) {
6386
6387 SortArray<CanvasItem *, CanvasItemPtrSort> sorter;
6388 sorter.sort(child_items, child_item_count);
6389 }
6390
6391 if (ci->z_relative)
6392 p_z = CLAMP(p_z + ci->z, CANVAS_ITEM_Z_MIN, CANVAS_ITEM_Z_MAX);
6393 else
6394 p_z = ci->z;
6395
6396 for (int i = 0; i < child_item_count; i++) {
6397
6398 if (child_items[i]->ontop)
6399 continue;
6400 _render_canvas_item(child_items[i], xform, p_clip_rect, opacity, p_z, z_list, z_last_list, (CanvasItem *)ci->final_clip_owner, p_material_owner);
6401 }
6402
6403 if (ci->copy_back_buffer) {
6404
6405 ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
6406 }
6407
6408 if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect)) || ci->vp_render || ci->copy_back_buffer) {
6409 //something to draw?
6410 ci->final_transform = xform;
6411 ci->final_opacity = opacity * ci->self_opacity;
6412 ci->global_rect_cache = global_rect;
6413 ci->global_rect_cache.pos -= p_clip_rect.pos;
6414 ci->light_masked = false;
6415
6416 int zidx = p_z - CANVAS_ITEM_Z_MIN;
6417
6418 if (z_last_list[zidx]) {
6419 z_last_list[zidx]->next = ci;
6420 z_last_list[zidx] = ci;
6421
6422 } else {
6423 z_list[zidx] = ci;
6424 z_last_list[zidx] = ci;
6425 }
6426
6427 ci->next = NULL;
6428 }
6429
6430 for (int i = 0; i < child_item_count; i++) {
6431
6432 if (!child_items[i]->ontop)
6433 continue;
6434 _render_canvas_item(child_items[i], xform, p_clip_rect, opacity, p_z, z_list, z_last_list, (CanvasItem *)ci->final_clip_owner, p_material_owner);
6435 }
6436 }
6437
_light_mask_canvas_items(int p_z,Rasterizer::CanvasItem * p_canvas_item,Rasterizer::CanvasLight * p_masked_lights)6438 void VisualServerRaster::_light_mask_canvas_items(int p_z, Rasterizer::CanvasItem *p_canvas_item, Rasterizer::CanvasLight *p_masked_lights) {
6439
6440 if (!p_masked_lights)
6441 return;
6442
6443 Rasterizer::CanvasItem *ci = p_canvas_item;
6444
6445 while (ci) {
6446
6447 Rasterizer::CanvasLight *light = p_masked_lights;
6448 while (light) {
6449
6450 if (ci->light_mask & light->item_mask && p_z >= light->z_min && p_z <= light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache, light->rect_cache)) {
6451 ci->light_masked = true;
6452 }
6453
6454 light = light->mask_next_ptr;
6455 }
6456
6457 ci = ci->next;
6458 }
6459 }
6460
_render_canvas(Canvas * p_canvas,const Matrix32 & p_transform,Rasterizer::CanvasLight * p_lights,Rasterizer::CanvasLight * p_masked_lights)6461 void VisualServerRaster::_render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights, Rasterizer::CanvasLight *p_masked_lights) {
6462
6463 rasterizer->canvas_begin();
6464
6465 int l = p_canvas->child_items.size();
6466 Canvas::ChildItem *ci = p_canvas->child_items.ptr();
6467
6468 bool has_mirror = false;
6469 for (int i = 0; i < l; i++) {
6470 if (ci[i].mirror.x || ci[i].mirror.y) {
6471 has_mirror = true;
6472 break;
6473 }
6474 }
6475
6476 Rect2 clip_rect(viewport_rect.x, viewport_rect.y, viewport_rect.width, viewport_rect.height);
6477 if (!has_mirror) {
6478
6479 static const int z_range = CANVAS_ITEM_Z_MAX - CANVAS_ITEM_Z_MIN + 1;
6480 Rasterizer::CanvasItem *z_list[z_range];
6481 Rasterizer::CanvasItem *z_last_list[z_range];
6482
6483 for (int i = 0; i < z_range; i++) {
6484 z_list[i] = NULL;
6485 z_last_list[i] = NULL;
6486 }
6487 for (int i = 0; i < l; i++) {
6488 _render_canvas_item(ci[i].item, p_transform, clip_rect, 1.0, 0, z_list, z_last_list, NULL, NULL);
6489 }
6490
6491 for (int i = 0; i < z_range; i++) {
6492 if (!z_list[i])
6493 continue;
6494
6495 if (p_masked_lights) {
6496 _light_mask_canvas_items(CANVAS_ITEM_Z_MIN + i, z_list[i], p_masked_lights);
6497 }
6498
6499 rasterizer->canvas_render_items(z_list[i], CANVAS_ITEM_Z_MIN + i, p_canvas->modulate, p_lights);
6500 }
6501 } else {
6502
6503 for (int i = 0; i < l; i++) {
6504
6505 Canvas::ChildItem &ci = p_canvas->child_items[i];
6506 _render_canvas_item_tree(ci.item, p_transform, clip_rect, p_canvas->modulate, p_lights);
6507
6508 //mirroring (useful for scrolling backgrounds)
6509 if (ci.mirror.x != 0) {
6510
6511 Matrix32 xform2 = p_transform * Matrix32(0, Vector2(ci.mirror.x, 0));
6512 _render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
6513 }
6514 if (ci.mirror.y != 0) {
6515
6516 Matrix32 xform2 = p_transform * Matrix32(0, Vector2(0, ci.mirror.y));
6517 _render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
6518 }
6519 if (ci.mirror.y != 0 && ci.mirror.x != 0) {
6520
6521 Matrix32 xform2 = p_transform * Matrix32(0, ci.mirror);
6522 _render_canvas_item_tree(ci.item, xform2, clip_rect, p_canvas->modulate, p_lights);
6523 }
6524 }
6525 }
6526 }
6527
_draw_viewport_camera(Viewport * p_viewport,bool p_ignore_camera)6528 void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport, bool p_ignore_camera) {
6529
6530 Camera *camera = NULL;
6531 if (camera_owner.owns(p_viewport->camera))
6532 camera = camera_owner.get(p_viewport->camera);
6533 Scenario *scenario = scenario_owner.get(p_viewport->scenario);
6534
6535 _update_instances(); // check dirty instances before rendering
6536
6537 if (p_ignore_camera)
6538 _render_no_camera(p_viewport, camera, scenario);
6539 else
6540 _render_camera(p_viewport, camera, scenario);
6541 }
6542
_draw_viewport(Viewport * p_viewport,int p_ofs_x,int p_ofs_y,int p_parent_w,int p_parent_h)6543 void VisualServerRaster::_draw_viewport(Viewport *p_viewport, int p_ofs_x, int p_ofs_y, int p_parent_w, int p_parent_h) {
6544
6545 ViewportRect desired_rect = p_viewport->rect;
6546 ViewportRect old_rect = viewport_rect;
6547 // bool vpchanged=false;
6548 // convert default expanding viewports to actual size
6549 //if (desired_rect.x==0 && desired_rect.y==0 && desired_rect.width==0 && desired_rect.height==0) {
6550 if (p_parent_w != 0 && p_parent_h != 0) {
6551
6552 desired_rect.width = p_parent_w;
6553 desired_rect.height = p_parent_h;
6554 }
6555
6556 ERR_FAIL_COND(desired_rect.width <= 0 || desired_rect.height <= 0);
6557
6558 desired_rect.x += p_ofs_x;
6559 desired_rect.y += p_ofs_y;
6560
6561 // if the viewport is different than the actual one, change it
6562
6563 if (p_viewport->render_target.is_valid() || viewport_rect.x != desired_rect.x ||
6564 viewport_rect.y != desired_rect.y ||
6565 viewport_rect.width != desired_rect.width ||
6566 viewport_rect.height != desired_rect.height) {
6567
6568 viewport_rect = desired_rect;
6569 rasterizer->set_viewport(viewport_rect);
6570 }
6571
6572 /* Camera should always be BEFORE any other 3D */
6573
6574 bool scenario_draw_canvas_bg = false;
6575 int scenario_canvas_max_layer = 0;
6576
6577 if (!p_viewport->hide_canvas && !p_viewport->disable_environment && scenario_owner.owns(p_viewport->scenario)) {
6578
6579 Scenario *scenario = scenario_owner.get(p_viewport->scenario);
6580 if (scenario->environment.is_valid()) {
6581 if (rasterizer->is_environment(scenario->environment)) {
6582 scenario_draw_canvas_bg = rasterizer->environment_get_background(scenario->environment) == VS::ENV_BG_CANVAS;
6583 scenario_canvas_max_layer = rasterizer->environment_get_background_param(scenario->environment, VS::ENV_BG_PARAM_CANVAS_MAX_LAYER);
6584 }
6585 }
6586 }
6587
6588 bool can_draw_3d = !p_viewport->hide_scenario && camera_owner.owns(p_viewport->camera) && scenario_owner.owns(p_viewport->scenario);
6589
6590 if (scenario_draw_canvas_bg) {
6591
6592 rasterizer->begin_canvas_bg();
6593 }
6594
6595 if (!scenario_draw_canvas_bg && can_draw_3d) {
6596
6597 _draw_viewport_camera(p_viewport, false);
6598
6599 } else if (true /*|| !p_viewport->canvas_list.empty()*/) {
6600
6601 //clear the viewport black because of no camera? i seriously should..
6602 if (p_viewport->render_target_clear_on_new_frame || p_viewport->render_target_clear) {
6603 if (p_viewport->transparent_bg) {
6604 rasterizer->clear_viewport(Color(0, 0, 0, 0));
6605 } else {
6606 Color cc = clear_color;
6607 if (scenario_draw_canvas_bg)
6608 cc.a = 0;
6609 rasterizer->clear_viewport(cc);
6610 }
6611 p_viewport->render_target_clear = false;
6612 }
6613 }
6614
6615 if (!p_viewport->hide_canvas) {
6616 int i = 0;
6617
6618 Map<Viewport::CanvasKey, Viewport::CanvasData *> canvas_map;
6619
6620 Rect2 clip_rect(0, 0, viewport_rect.width, viewport_rect.height);
6621 Rasterizer::CanvasLight *lights = NULL;
6622 Rasterizer::CanvasLight *lights_with_shadow = NULL;
6623 Rasterizer::CanvasLight *lights_with_mask = NULL;
6624 Rect2 shadow_rect;
6625
6626 int light_count = 0;
6627
6628 for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
6629
6630 Matrix32 xf = p_viewport->global_transform * E->get().transform;
6631
6632 //find lights in canvas
6633
6634 for (Set<Rasterizer::CanvasLight *>::Element *F = E->get().canvas->lights.front(); F; F = F->next()) {
6635
6636 Rasterizer::CanvasLight *cl = F->get();
6637 if (cl->enabled && cl->texture.is_valid()) {
6638 //not super efficient..
6639 Size2 tsize(rasterizer->texture_get_width(cl->texture), rasterizer->texture_get_height(cl->texture));
6640 tsize *= cl->scale;
6641
6642 Vector2 offset = tsize / 2.0;
6643 cl->rect_cache = Rect2(-offset + cl->texture_offset, tsize);
6644 cl->xform_cache = xf * cl->xform;
6645
6646 if (clip_rect.intersects_transformed(cl->xform_cache, cl->rect_cache)) {
6647
6648 cl->filter_next_ptr = lights;
6649 lights = cl;
6650 cl->texture_cache = NULL;
6651 Matrix32 scale;
6652 scale.scale(cl->rect_cache.size);
6653 scale.elements[2] = cl->rect_cache.pos;
6654 cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse();
6655 cl->light_shader_pos = cl->xform_cache[2];
6656 if (cl->shadow_buffer.is_valid()) {
6657
6658 cl->shadows_next_ptr = lights_with_shadow;
6659 if (lights_with_shadow == NULL) {
6660 shadow_rect = cl->xform_cache.xform(cl->rect_cache);
6661 } else {
6662 shadow_rect = shadow_rect.merge(cl->xform_cache.xform(cl->rect_cache));
6663 }
6664 lights_with_shadow = cl;
6665 cl->radius_cache = cl->rect_cache.size.length();
6666 }
6667 if (cl->mode == CANVAS_LIGHT_MODE_MASK) {
6668 cl->mask_next_ptr = lights_with_mask;
6669 lights_with_mask = cl;
6670 }
6671
6672 light_count++;
6673 }
6674 }
6675 }
6676
6677 //print_line("lights: "+itos(light_count));
6678 canvas_map[Viewport::CanvasKey(E->key(), E->get().layer)] = &E->get();
6679 }
6680
6681 if (lights_with_shadow) {
6682 //update shadows if any
6683
6684 Rasterizer::CanvasLightOccluderInstance *occluders = NULL;
6685
6686 //make list of occluders
6687 for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
6688
6689 Matrix32 xf = p_viewport->global_transform * E->get().transform;
6690
6691 for (Set<Rasterizer::CanvasLightOccluderInstance *>::Element *F = E->get().canvas->occluders.front(); F; F = F->next()) {
6692
6693 if (!F->get()->enabled)
6694 continue;
6695 F->get()->xform_cache = xf * F->get()->xform;
6696 if (shadow_rect.intersects_transformed(F->get()->xform_cache, F->get()->aabb_cache)) {
6697
6698 F->get()->next = occluders;
6699 occluders = F->get();
6700 }
6701 }
6702 }
6703 //update the light shadowmaps with them
6704 Rasterizer::CanvasLight *light = lights_with_shadow;
6705 while (light) {
6706
6707 rasterizer->canvas_light_shadow_buffer_update(light->shadow_buffer, light->xform_cache.affine_inverse(), light->item_mask, light->radius_cache / 1000.0, light->radius_cache * 1.1, occluders, &light->shadow_matrix_cache);
6708 light = light->shadows_next_ptr;
6709 }
6710
6711 rasterizer->set_viewport(viewport_rect); //must reset viewport afterwards
6712 }
6713
6714 if (scenario_draw_canvas_bg && canvas_map.front() && canvas_map.front()->key().layer > scenario_canvas_max_layer) {
6715
6716 _draw_viewport_camera(p_viewport, !can_draw_3d);
6717 scenario_draw_canvas_bg = false;
6718 }
6719
6720 for (Map<Viewport::CanvasKey, Viewport::CanvasData *>::Element *E = canvas_map.front(); E; E = E->next()) {
6721
6722 // print_line("canvas "+itos(i)+" size: "+itos(I->get()->canvas->child_items.size()));
6723 //print_line("GT "+p_viewport->global_transform+". CT: "+E->get()->transform);
6724 Matrix32 xform = p_viewport->global_transform * E->get()->transform;
6725
6726 Rasterizer::CanvasLight *canvas_lights = NULL;
6727
6728 Rasterizer::CanvasLight *ptr = lights;
6729 while (ptr) {
6730 if (E->get()->layer >= ptr->layer_min && E->get()->layer <= ptr->layer_max) {
6731 ptr->next_ptr = canvas_lights;
6732 canvas_lights = ptr;
6733 }
6734 ptr = ptr->filter_next_ptr;
6735 }
6736
6737 _render_canvas(E->get()->canvas, xform, canvas_lights, lights_with_mask);
6738 i++;
6739
6740 if (scenario_draw_canvas_bg && E->key().layer >= scenario_canvas_max_layer) {
6741 _draw_viewport_camera(p_viewport, !can_draw_3d);
6742 scenario_draw_canvas_bg = false;
6743 }
6744 }
6745
6746 if (scenario_draw_canvas_bg) {
6747 _draw_viewport_camera(p_viewport, !can_draw_3d);
6748 scenario_draw_canvas_bg = false;
6749 }
6750
6751 // rasterizer->canvas_debug_viewport_shadows(lights_with_shadow);
6752 }
6753
6754 //capture
6755
6756 if (p_viewport->queue_capture) {
6757
6758 rasterizer->capture_viewport(&p_viewport->capture);
6759 p_viewport->queue_capture = false;
6760 }
6761
6762 //restore
6763 if (viewport_rect.x != old_rect.x ||
6764 viewport_rect.y != old_rect.y ||
6765 viewport_rect.width != old_rect.width ||
6766 viewport_rect.height != old_rect.height) {
6767
6768 viewport_rect = old_rect;
6769
6770 rasterizer->set_viewport(viewport_rect);
6771 }
6772 }
6773
_draw_viewports()6774 void VisualServerRaster::_draw_viewports() {
6775
6776 //draw viewports for render targets
6777
6778 List<Viewport *> to_blit;
6779 List<Viewport *> to_disable;
6780 for (SelfList<Viewport> *E = viewport_update_list.first(); E; E = E->next()) {
6781
6782 Viewport *vp = E->self();
6783 ERR_CONTINUE(!vp);
6784 if (
6785 vp->render_target_update_mode == RENDER_TARGET_UPDATE_WHEN_VISIBLE &&
6786 !vp->rendered_in_prev_frame &&
6787 !vp->queue_capture) {
6788
6789 continue;
6790 }
6791
6792 if (vp->rt_to_screen_rect != Rect2())
6793 to_blit.push_back(vp);
6794
6795 rasterizer->set_render_target(vp->render_target, vp->transparent_bg, vp->render_target_vflip);
6796 _draw_viewport(vp, 0, 0, vp->rect.width, vp->rect.height);
6797
6798 if ((vp->queue_capture && vp->render_target_update_mode == RENDER_TARGET_UPDATE_DISABLED) || vp->render_target_update_mode == RENDER_TARGET_UPDATE_ONCE) {
6799 //was only enabled for capture
6800 to_disable.push_back(vp);
6801 vp->render_target_update_mode = RENDER_TARGET_UPDATE_DISABLED;
6802 }
6803 }
6804
6805 rasterizer->set_render_target(RID());
6806
6807 while (to_disable.size()) {
6808 //disable again because it was only for capture
6809 viewport_update_list.remove(&to_disable.front()->get()->update_list);
6810 to_disable.pop_front();
6811 }
6812
6813 //draw RTs directly to screen when requested
6814
6815 for (List<Viewport *>::Element *E = to_blit.front(); E; E = E->next()) {
6816
6817 int window_w = OS::get_singleton()->get_video_mode().width;
6818 int window_h = OS::get_singleton()->get_video_mode().height;
6819
6820 ViewportRect desired_rect;
6821 desired_rect.x = desired_rect.y = 0;
6822 desired_rect.width = window_w;
6823 desired_rect.height = window_h;
6824
6825 if (viewport_rect.x != desired_rect.x ||
6826 viewport_rect.y != desired_rect.y ||
6827 viewport_rect.width != desired_rect.width ||
6828 viewport_rect.height != desired_rect.height) {
6829
6830 viewport_rect = desired_rect;
6831
6832 rasterizer->set_viewport(viewport_rect);
6833 }
6834
6835 rasterizer->canvas_begin();
6836 rasterizer->canvas_disable_blending();
6837 rasterizer->canvas_begin_rect(Matrix32());
6838 rasterizer->canvas_draw_rect(E->get()->rt_to_screen_rect, 0, Rect2(Point2(), E->get()->rt_to_screen_rect.size), E->get()->render_target_texture, Color(1, 1, 1));
6839 }
6840
6841 //draw viewports attached to screen
6842
6843 for (Map<RID, int>::Element *E = screen_viewports.front(); E; E = E->next()) {
6844
6845 Viewport *vp = viewport_owner.get(E->key());
6846 ERR_CONTINUE(!vp);
6847
6848 int window_w = OS::get_singleton()->get_video_mode(E->get()).width;
6849 int window_h = OS::get_singleton()->get_video_mode(E->get()).height;
6850
6851 Rect2 r(0, 0, vp->rect.width, vp->rect.height);
6852 if (r.size.width == 0)
6853 r.size.width = window_w;
6854 if (r.size.height == 0)
6855 r.size.height = window_h;
6856
6857 _draw_viewport(vp, r.pos.x, r.pos.y, r.size.width, r.size.height);
6858 }
6859
6860 //check when a viewport associated to a render target was drawn
6861
6862 for (SelfList<Viewport> *E = viewport_update_list.first(); E; E = E->next()) {
6863
6864 Viewport *vp = E->self();
6865 ERR_CONTINUE(!vp);
6866 if (vp->render_target_update_mode != RENDER_TARGET_UPDATE_WHEN_VISIBLE)
6867 continue;
6868 vp->rendered_in_prev_frame = rasterizer->render_target_renedered_in_frame(vp->render_target);
6869 }
6870 }
6871
_draw_cursors_and_margins()6872 void VisualServerRaster::_draw_cursors_and_margins() {
6873
6874 int window_w = OS::get_singleton()->get_video_mode().width;
6875 int window_h = OS::get_singleton()->get_video_mode().height;
6876
6877 ViewportRect desired_rect;
6878 desired_rect.x = desired_rect.y = 0;
6879 desired_rect.width = window_w;
6880 desired_rect.height = window_h;
6881
6882 if (viewport_rect.x != desired_rect.x ||
6883 viewport_rect.y != desired_rect.y ||
6884 viewport_rect.width != desired_rect.width ||
6885 viewport_rect.height != desired_rect.height) {
6886
6887 viewport_rect = desired_rect;
6888
6889 rasterizer->set_viewport(viewport_rect);
6890 }
6891
6892 rasterizer->canvas_begin();
6893 rasterizer->canvas_begin_rect(Matrix32());
6894
6895 if (black_image[MARGIN_LEFT].is_valid()) {
6896 Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_LEFT]), rasterizer->texture_get_height(black_image[MARGIN_LEFT]));
6897 rasterizer->canvas_draw_rect(Rect2(0, 0, black_margin[MARGIN_LEFT], window_h), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_LEFT], Color(1, 1, 1));
6898 } else if (black_margin[MARGIN_LEFT])
6899 rasterizer->canvas_draw_rect(Rect2(0, 0, black_margin[MARGIN_LEFT], window_h), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
6900
6901 if (black_image[MARGIN_RIGHT].is_valid()) {
6902 Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_RIGHT]), rasterizer->texture_get_height(black_image[MARGIN_RIGHT]));
6903 rasterizer->canvas_draw_rect(Rect2(window_w - black_margin[MARGIN_RIGHT], 0, black_margin[MARGIN_RIGHT], window_h), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_RIGHT], Color(1, 1, 1));
6904 } else if (black_margin[MARGIN_RIGHT])
6905 rasterizer->canvas_draw_rect(Rect2(window_w - black_margin[MARGIN_RIGHT], 0, black_margin[MARGIN_RIGHT], window_h), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
6906
6907 if (black_image[MARGIN_TOP].is_valid()) {
6908 Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_TOP]), rasterizer->texture_get_height(black_image[MARGIN_TOP]));
6909 rasterizer->canvas_draw_rect(Rect2(0, 0, window_w, black_margin[MARGIN_TOP]), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_TOP], Color(1, 1, 1));
6910
6911 } else if (black_margin[MARGIN_TOP]) {
6912 rasterizer->canvas_draw_rect(Rect2(0, 0, window_w, black_margin[MARGIN_TOP]), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
6913 }
6914
6915 if (black_image[MARGIN_BOTTOM].is_valid()) {
6916
6917 Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_BOTTOM]), rasterizer->texture_get_height(black_image[MARGIN_BOTTOM]));
6918 rasterizer->canvas_draw_rect(Rect2(0, window_h - black_margin[MARGIN_BOTTOM], window_w, black_margin[MARGIN_BOTTOM]), 0, Rect2(0, 0, sz.x, sz.y), black_image[MARGIN_BOTTOM], Color(1, 1, 1));
6919 } else if (black_margin[MARGIN_BOTTOM]) {
6920 rasterizer->canvas_draw_rect(Rect2(0, window_h - black_margin[MARGIN_BOTTOM], window_w, black_margin[MARGIN_BOTTOM]), 0, Rect2(0, 0, 1, 1), RID(), Color(0, 0, 0));
6921 }
6922
6923 rasterizer->canvas_end_rect();
6924 };
6925
sync()6926 void VisualServerRaster::sync() {
6927 //do none
6928 }
6929
draw()6930 void VisualServerRaster::draw() {
6931 //if (changes)
6932 // print_line("changes: "+itos(changes));
6933 changes = 0;
6934 shadows_enabled = GLOBAL_DEF("render/shadows_enabled", true);
6935 room_cull_enabled = GLOBAL_DEF("render/room_cull_enabled", true);
6936 light_discard_enabled = GLOBAL_DEF("render/light_discard_enabled", true);
6937 rasterizer->begin_frame();
6938 _draw_viewports();
6939 _draw_cursors_and_margins();
6940 rasterizer->end_frame();
6941 draw_extra_frame = rasterizer->needs_to_draw_next_frame();
6942 }
6943
has_changed() const6944 bool VisualServerRaster::has_changed() const {
6945
6946 return changes > 0 || draw_extra_frame;
6947 }
6948
get_render_info(RenderInfo p_info)6949 int VisualServerRaster::get_render_info(RenderInfo p_info) {
6950
6951 return rasterizer->get_render_info(p_info);
6952 }
6953
has_feature(Features p_feature) const6954 bool VisualServerRaster::has_feature(Features p_feature) const {
6955
6956 return rasterizer->has_feature(p_feature); // lies for now
6957 }
6958
set_default_clear_color(const Color & p_color)6959 void VisualServerRaster::set_default_clear_color(const Color &p_color) {
6960
6961 clear_color = p_color;
6962 }
6963
get_default_clear_color() const6964 Color VisualServerRaster::get_default_clear_color() const {
6965
6966 return clear_color;
6967 }
6968
set_time_scale(float p_scale)6969 void VisualServerRaster::set_time_scale(float p_scale) {
6970
6971 rasterizer->set_time_scale(p_scale);
6972 }
6973
set_boot_image(const Image & p_image,const Color & p_color,bool p_scale)6974 void VisualServerRaster::set_boot_image(const Image &p_image, const Color &p_color, bool p_scale) {
6975
6976 if (p_image.empty())
6977 return;
6978
6979 rasterizer->restore_framebuffer();
6980
6981 rasterizer->begin_frame();
6982
6983 int window_w = OS::get_singleton()->get_video_mode(0).width;
6984 int window_h = OS::get_singleton()->get_video_mode(0).height;
6985 ViewportRect vr;
6986 vr.x = 0;
6987 vr.y = 0;
6988 vr.width = OS::get_singleton()->get_video_mode(0).width;
6989 vr.height = OS::get_singleton()->get_video_mode(0).height;
6990 rasterizer->set_viewport(vr);
6991 rasterizer->clear_viewport(p_color);
6992 rasterizer->canvas_begin();
6993 RID texture = texture_create();
6994 texture_allocate(texture, p_image.get_width(), p_image.get_height(), p_image.get_format(), TEXTURE_FLAG_FILTER);
6995 texture_set_data(texture, p_image);
6996 rasterizer->canvas_begin_rect(Matrix32());
6997 Rect2 imgrect(0, 0, p_image.get_width(), p_image.get_height());
6998 Rect2 screenrect;
6999 if (p_scale) {
7000
7001 if (window_w > window_h) {
7002 //scale horizontally
7003 screenrect.size.y = window_h;
7004 screenrect.size.x = imgrect.size.x * window_h / imgrect.size.y;
7005 screenrect.pos.x = (window_w - screenrect.size.x) / 2;
7006
7007 } else {
7008 //scale vertically
7009 screenrect.size.x = window_w;
7010 screenrect.size.y = imgrect.size.y * window_w / imgrect.size.x;
7011 screenrect.pos.y = (window_h - screenrect.size.y) / 2;
7012 }
7013 } else {
7014
7015 screenrect = imgrect;
7016 screenrect.pos += ((Size2(vr.width, vr.height) - screenrect.size) / 2.0).floor();
7017 }
7018 rasterizer->canvas_draw_rect(screenrect, 0, imgrect, texture, Color(1, 1, 1, 1));
7019 rasterizer->canvas_end_rect();
7020
7021 rasterizer->end_frame();
7022 rasterizer->flush_frame();
7023
7024 free(texture); // free since it's only one frame that stays there
7025 }
7026
init()7027 void VisualServerRaster::init() {
7028
7029 rasterizer->init();
7030
7031 shadows_enabled = GLOBAL_DEF("render/shadows_enabled", true);
7032 //default_scenario = scenario_create();
7033 //default_viewport = viewport_create();
7034 for (int i = 0; i < 4; i++)
7035 black_margin[i] = 0;
7036
7037 aabb_random_points.resize(GLOBAL_DEF("render/aabb_random_points", 16));
7038 for (int i = 0; i < aabb_random_points.size(); i++)
7039 aabb_random_points[i] = Vector3(Math::random(0, 1), Math::random(0, 1), Math::random(0, 1));
7040 transformed_aabb_random_points.resize(aabb_random_points.size());
7041 changes = 0;
7042 }
7043
_clean_up_owner(RID_OwnerBase * p_owner,String p_type)7044 void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner, String p_type) {
7045
7046 List<RID> rids;
7047 p_owner->get_owned_list(&rids);
7048
7049 int lost = 0;
7050 for (List<RID>::Element *I = rids.front(); I; I = I->next()) {
7051 if (OS::get_singleton()->is_stdout_verbose()) {
7052 lost++;
7053 }
7054 free(I->get());
7055 }
7056
7057 if (lost)
7058 print_line("VisualServerRaster: WARNING: Lost " + itos(lost) + " RIDs of type " + p_type);
7059 }
7060
finish()7061 void VisualServerRaster::finish() {
7062
7063 if (test_cube.is_valid())
7064 free(test_cube);
7065
7066 _free_internal_rids();
7067
7068 _clean_up_owner(&room_owner, "Room");
7069 _clean_up_owner(&portal_owner, "Portal");
7070
7071 _clean_up_owner(&camera_owner, "Camera");
7072 _clean_up_owner(&viewport_owner, "Viewport");
7073
7074 _clean_up_owner(&scenario_owner, "Scenario");
7075 _clean_up_owner(&instance_owner, "Instance");
7076
7077 _clean_up_owner(&canvas_owner, "Canvas");
7078 _clean_up_owner(&canvas_item_owner, "CanvasItem");
7079
7080 rasterizer->finish();
7081 octree_allocator.clear();
7082
7083 if (instance_dependency_map.size()) {
7084 print_line("Base resources missing amount: " + itos(instance_dependency_map.size()));
7085 }
7086 ERR_FAIL_COND(instance_dependency_map.size());
7087 }
7088
get_test_cube()7089 RID VisualServerRaster::get_test_cube() {
7090
7091 if (test_cube.is_valid())
7092 return test_cube;
7093
7094 test_cube = _make_test_cube();
7095 return test_cube;
7096 }
7097
VisualServerRaster(Rasterizer * p_rasterizer)7098 VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer) {
7099
7100 rasterizer = p_rasterizer;
7101 rasterizer->draw_viewport_func = _render_canvas_item_viewport;
7102 instance_update_list = NULL;
7103 render_pass = 0;
7104 clear_color = Color(0.3, 0.3, 0.3, 1.0);
7105 OctreeAllocator::allocator = &octree_allocator;
7106 draw_extra_frame = false;
7107 }
7108
~VisualServerRaster()7109 VisualServerRaster::~VisualServerRaster() {
7110 }
7111