godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/servers/visual/visual_server_raster.cpp

7768 lines
206 KiB
C++
Raw Blame History

/*************************************************************************/
/* visual_server_raster.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "visual_server_raster.h"
#include "os/os.h"
#include "globals.h"
#include "default_mouse_cursor.xpm"
#include "sort.h"
#include "io/marshalls.h"
// careful, these may run in different threads than the visual server
BalloonAllocator<> *VisualServerRaster::OctreeAllocator::allocator=NULL;
#define VS_CHANGED\
changes++;\
// print_line(__FUNCTION__);
RID VisualServerRaster::texture_create() {
return rasterizer->texture_create();
}
void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
rasterizer->texture_allocate(p_texture,p_width,p_height,p_format,p_flags);
}
void VisualServerRaster::texture_set_flags(RID p_texture,uint32_t p_flags) {
VS_CHANGED;
rasterizer->texture_set_flags(p_texture,p_flags);
}
void VisualServerRaster::texture_set_data(RID p_texture,const Image& p_image,CubeMapSide p_cube_side) {
VS_CHANGED;
rasterizer->texture_set_data(p_texture,p_image,p_cube_side);
}
Image VisualServerRaster::texture_get_data(RID p_texture,CubeMapSide p_cube_side) const {
return rasterizer->texture_get_data(p_texture,p_cube_side);
}
uint32_t VisualServerRaster::texture_get_flags(RID p_texture) const {
return rasterizer->texture_get_flags(p_texture);
}
Image::Format VisualServerRaster::texture_get_format(RID p_texture) const {
return rasterizer->texture_get_format(p_texture);
}
uint32_t VisualServerRaster::texture_get_width(RID p_texture) const {
return rasterizer->texture_get_width(p_texture);
}
uint32_t VisualServerRaster::texture_get_height(RID p_texture) const {
return rasterizer->texture_get_height(p_texture);
}
void VisualServerRaster::texture_set_size_override(RID p_texture,int p_width, int p_height) {
rasterizer->texture_set_size_override(p_texture,p_width,p_height);
}
bool VisualServerRaster::texture_can_stream(RID p_texture) const {
return false;
}
void VisualServerRaster::texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const {
rasterizer->texture_set_reload_hook(p_texture,p_owner,p_function);
}
void VisualServerRaster::texture_set_path(RID p_texture,const String& p_path) {
rasterizer->texture_set_path(p_texture,p_path);
}
String VisualServerRaster::texture_get_path(RID p_texture) const{
return rasterizer->texture_get_path(p_texture);
}
void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info){
rasterizer->texture_debug_usage(r_info);
}
void VisualServerRaster::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
rasterizer->texture_set_shrink_all_x2_on_set_data(p_enable);
}
/* SHADER API */
RID VisualServerRaster::shader_create(ShaderMode p_mode) {
return rasterizer->shader_create(p_mode);
}
void VisualServerRaster::shader_set_mode(RID p_shader,ShaderMode p_mode){
VS_CHANGED;
rasterizer->shader_set_mode(p_shader,p_mode);
}
VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader) const{
return rasterizer->shader_get_mode(p_shader);
}
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) {
VS_CHANGED;
rasterizer->shader_set_code(p_shader,p_vertex,p_fragment,p_light,p_vertex_ofs,p_fragment_ofs,p_light_ofs);
}
String VisualServerRaster::shader_get_vertex_code(RID p_shader) const{
return rasterizer->shader_get_vertex_code(p_shader);
}
String VisualServerRaster::shader_get_fragment_code(RID p_shader) const{
return rasterizer->shader_get_fragment_code(p_shader);
}
String VisualServerRaster::shader_get_light_code(RID p_shader) const{
return rasterizer->shader_get_light_code(p_shader);
}
void VisualServerRaster::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
return rasterizer->shader_get_param_list(p_shader,p_param_list);
}
void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture) {
rasterizer->shader_set_default_texture_param(p_shader,p_name,p_texture);
}
RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
return rasterizer->shader_get_default_texture_param(p_shader,p_name);
}
/* Material */
RID VisualServerRaster::material_create() {
return rasterizer->material_create();
}
void VisualServerRaster::material_set_shader(RID p_material, RID p_shader) {
VS_CHANGED;
rasterizer->material_set_shader(p_material, p_shader );
}
RID VisualServerRaster::material_get_shader(RID p_material) const {
return rasterizer->material_get_shader(p_material);
}
void VisualServerRaster::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value) {
VS_CHANGED;
rasterizer->material_set_param(p_material, p_param,p_value );
}
Variant VisualServerRaster::material_get_param(RID p_material, const StringName& p_param) const {
return rasterizer->material_get_param(p_material,p_param);
}
void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag,bool p_enabled) {
VS_CHANGED;
rasterizer->material_set_flag(p_material,p_flag,p_enabled);
}
void VisualServerRaster::material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode) {
VS_CHANGED;
rasterizer->material_set_depth_draw_mode(p_material,p_mode);
}
VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p_material) const {
return rasterizer->material_get_depth_draw_mode(p_material);
}
bool VisualServerRaster::material_get_flag(RID p_material,MaterialFlag p_flag) const {
return rasterizer->material_get_flag(p_material,p_flag);
}
void VisualServerRaster::material_set_blend_mode(RID p_material,MaterialBlendMode p_mode) {
VS_CHANGED;
rasterizer->material_set_blend_mode(p_material,p_mode);
}
VS::MaterialBlendMode VisualServerRaster::material_get_blend_mode(RID p_material) const {
return rasterizer->material_get_blend_mode(p_material);
}
void VisualServerRaster::material_set_line_width(RID p_material,float p_line_width) {
VS_CHANGED;
rasterizer->material_set_line_width(p_material,p_line_width);
}
float VisualServerRaster::material_get_line_width(RID p_material) const {
return rasterizer->material_get_line_width(p_material);
}
/* FIXED MATERIAL */
RID VisualServerRaster::fixed_material_create() {
return rasterizer->fixed_material_create();
}
void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled) {
rasterizer->fixed_material_set_flag(p_material,p_flag,p_enabled);
}
bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag) const {
return rasterizer->fixed_material_get_flag(p_material,p_flag);
}
void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant& p_value) {
VS_CHANGED;
rasterizer->fixed_material_set_parameter(p_material,p_parameter,p_value);
}
Variant VisualServerRaster::fixed_material_get_param(RID p_material,FixedMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_parameter(p_material,p_parameter);
}
void VisualServerRaster::fixed_material_set_texture(RID p_material,FixedMaterialParam p_parameter, RID p_texture) {
VS_CHANGED;
rasterizer->fixed_material_set_texture(p_material,p_parameter,p_texture);
}
RID VisualServerRaster::fixed_material_get_texture(RID p_material,FixedMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_texture(p_material,p_parameter);
}
void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material,FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode) {
VS_CHANGED;
rasterizer->fixed_material_set_texcoord_mode(p_material,p_parameter,p_mode);
}
VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material,FixedMaterialParam p_parameter) const {
return rasterizer->fixed_material_get_texcoord_mode(p_material,p_parameter);
}
void VisualServerRaster::fixed_material_set_point_size(RID p_material,float p_size) {
VS_CHANGED
rasterizer->fixed_material_set_point_size(p_material,p_size);
}
float VisualServerRaster::fixed_material_get_point_size(RID p_material) const{
return rasterizer->fixed_material_get_point_size(p_material);
}
void VisualServerRaster::fixed_material_set_uv_transform(RID p_material,const Transform& p_transform) {
VS_CHANGED;
rasterizer->fixed_material_set_uv_transform(p_material,p_transform);
}
Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) const {
return rasterizer->fixed_material_get_uv_transform(p_material);
}
void VisualServerRaster::fixed_material_set_light_shader(RID p_material,FixedMaterialLightShader p_shader) {
VS_CHANGED;
rasterizer->fixed_material_set_light_shader(p_material,p_shader);
}
VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material) const{
return rasterizer->fixed_material_get_light_shader(p_material);
}
/* MESH API */
RID VisualServerRaster::mesh_create() {
return rasterizer->mesh_create();
}
void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh,int p_amount) {
rasterizer->mesh_set_morph_target_count(p_mesh,p_amount);
int amount = rasterizer->mesh_get_morph_target_count(p_mesh);
Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_mesh );
if (!E)
return;
Set<RID>::Element *I = E->get().front();
while(I) {
Instance *ins = instance_owner.get( I->get() );
ins->data.morph_values.resize(amount);
I = I->next();
}
}
int VisualServerRaster::mesh_get_morph_target_count(RID p_mesh) const {
return rasterizer->mesh_get_morph_target_count(p_mesh);
}
void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh,MorphTargetMode p_mode) {
rasterizer->mesh_set_morph_target_mode(p_mesh,p_mode);
}
VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh) const{
return rasterizer->mesh_get_morph_target_mode(p_mesh);
}
void VisualServerRaster::mesh_add_custom_surface(RID p_mesh,const Variant& p_dat) {
}
void VisualServerRaster::mesh_add_surface(RID p_mesh,PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes,bool p_alpha_sort) {
VS_CHANGED;
_dependency_queue_update(p_mesh,true,true);
rasterizer->mesh_add_surface(p_mesh,p_primitive,p_arrays,p_blend_shapes,p_alpha_sort);
}
Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh,int p_surface) const {
return rasterizer->mesh_get_surface_arrays(p_mesh,p_surface);
}
Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh,int p_surface) const {
return rasterizer->mesh_get_surface_morph_arrays(p_mesh,p_surface);
}
void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material,bool p_owned){
VS_CHANGED;
rasterizer->mesh_surface_set_material(p_mesh,p_surface,p_material,p_owned);
}
RID VisualServerRaster::mesh_surface_get_material(RID p_mesh,int p_surface) const {
return rasterizer->mesh_surface_get_material(p_mesh,p_surface);
}
int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
return rasterizer->mesh_surface_get_array_len(p_mesh,p_surface);
}
int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
return rasterizer->mesh_surface_get_array_index_len(p_mesh,p_surface);
}
uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface) const{
return rasterizer->mesh_surface_get_format(p_mesh,p_surface);
}
VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
return rasterizer->mesh_surface_get_primitive_type(p_mesh,p_surface);
}
void VisualServerRaster::mesh_remove_surface(RID p_mesh,int p_surface){
rasterizer->mesh_remove_surface(p_mesh,p_surface);
_dependency_queue_update(p_mesh,true,true);
}
int VisualServerRaster::mesh_get_surface_count(RID p_mesh) const{
return rasterizer->mesh_get_surface_count(p_mesh);
}
void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb) {
VS_CHANGED;
_dependency_queue_update(p_mesh,true);
rasterizer->mesh_set_custom_aabb(p_mesh,p_aabb);
}
AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh) const {
return rasterizer->mesh_get_custom_aabb(p_mesh);
}
void VisualServerRaster::mesh_clear(RID p_mesh) {
ERR_FAIL_COND(!rasterizer->is_mesh(p_mesh));
while(rasterizer->mesh_get_surface_count(p_mesh)) {
rasterizer->mesh_remove_surface(p_mesh,0);
}
_dependency_queue_update(p_mesh,true,true);
}
/* MULTIMESH */
RID VisualServerRaster::multimesh_create() {
return rasterizer->multimesh_create();
}
void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh,int p_count) {
VS_CHANGED;
rasterizer->multimesh_set_instance_count(p_multimesh,p_count);
}
int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh) const {
return rasterizer->multimesh_get_instance_count(p_multimesh);
}
void VisualServerRaster::multimesh_set_mesh(RID p_multimesh,RID p_mesh) {
VS_CHANGED;
rasterizer->multimesh_set_mesh(p_multimesh,p_mesh);
}
void VisualServerRaster::multimesh_set_aabb(RID p_multimesh,const AABB& p_aabb) {
VS_CHANGED;
rasterizer->multimesh_set_aabb(p_multimesh,p_aabb);
_dependency_queue_update(p_multimesh,true);
}
void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform) {
VS_CHANGED;
rasterizer->multimesh_instance_set_transform(p_multimesh,p_index,p_transform);
}
void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color) {
VS_CHANGED;
rasterizer->multimesh_instance_set_color(p_multimesh,p_index,p_color);
}
RID VisualServerRaster::multimesh_get_mesh(RID p_multimesh) const {
return rasterizer->multimesh_get_mesh(p_multimesh);
}
AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh,const AABB& p_aabb) const {
return rasterizer->multimesh_get_aabb(p_multimesh);
}
Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh,int p_index) const {
return rasterizer->multimesh_instance_get_transform(p_multimesh,p_index);
}
Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh,int p_index) const {
return rasterizer->multimesh_instance_get_color(p_multimesh,p_index);
}
void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh,int p_visible) {
rasterizer->multimesh_set_visible_instances(p_multimesh,p_visible);
}
int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh) const {
return rasterizer->multimesh_get_visible_instances(p_multimesh);
}
/* IMMEDIATE API */
RID VisualServerRaster::immediate_create() {
return rasterizer->immediate_create();
}
void VisualServerRaster::immediate_begin(RID p_immediate,PrimitiveType p_primitive,RID p_texture){
rasterizer->immediate_begin(p_immediate,p_primitive,p_texture);
}
void VisualServerRaster::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
rasterizer->immediate_vertex(p_immediate,p_vertex);
}
void VisualServerRaster::immediate_normal(RID p_immediate,const Vector3& p_normal){
rasterizer->immediate_normal(p_immediate,p_normal);
}
void VisualServerRaster::immediate_tangent(RID p_immediate,const Plane& p_tangent){
rasterizer->immediate_tangent(p_immediate,p_tangent);
}
void VisualServerRaster::immediate_color(RID p_immediate,const Color& p_color){
rasterizer->immediate_color(p_immediate,p_color);
}
void VisualServerRaster::immediate_uv(RID p_immediate,const Vector2& p_uv){
rasterizer->immediate_uv(p_immediate,p_uv);
}
void VisualServerRaster::immediate_uv2(RID p_immediate,const Vector2& p_uv2){
rasterizer->immediate_uv2(p_immediate,p_uv2);
}
void VisualServerRaster::immediate_end(RID p_immediate){
VS_CHANGED;
_dependency_queue_update(p_immediate,true);
rasterizer->immediate_end(p_immediate);
}
void VisualServerRaster::immediate_clear(RID p_immediate){
VS_CHANGED;
_dependency_queue_update(p_immediate,true);
rasterizer->immediate_clear(p_immediate);
}
void VisualServerRaster::immediate_set_material(RID p_immediate,RID p_material) {
rasterizer->immediate_set_material(p_immediate,p_material);
}
RID VisualServerRaster::immediate_get_material(RID p_immediate) const {
return rasterizer->immediate_get_material(p_immediate);
}
/* PARTICLES API */
RID VisualServerRaster::particles_create() {
return rasterizer->particles_create();
}
void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount) {
VS_CHANGED;
rasterizer->particles_set_amount(p_particles,p_amount);
}
int VisualServerRaster::particles_get_amount(RID p_particles) const {
return rasterizer->particles_get_amount(p_particles);
}
void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting) {
VS_CHANGED;
rasterizer->particles_set_emitting(p_particles,p_emitting);
}
bool VisualServerRaster::particles_is_emitting(RID p_particles) const {
return rasterizer->particles_is_emitting(p_particles);
}
void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility) {
VS_CHANGED;
rasterizer->particles_set_visibility_aabb(p_particles, p_visibility);
}
AABB VisualServerRaster::particles_get_visibility_aabb(RID p_particles) const {
return rasterizer->particles_get_visibility_aabb(p_particles);
}
void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents) {
VS_CHANGED;
rasterizer->particles_set_emission_half_extents(p_particles,p_half_extents);
}
Vector3 VisualServerRaster::particles_get_emission_half_extents(RID p_particles) const {
return rasterizer->particles_get_emission_half_extents(p_particles);
}
void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity) {
VS_CHANGED;
rasterizer->particles_set_emission_base_velocity(p_particles,p_base_velocity);
}
Vector3 VisualServerRaster::particles_get_emission_base_velocity(RID p_particles) const {
return rasterizer->particles_get_emission_base_velocity(p_particles);
}
void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points) {
VS_CHANGED;
rasterizer->particles_set_emission_points(p_particles,p_points);
}
DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles) const {
return rasterizer->particles_get_emission_points(p_particles);
}
void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3& p_normal) {
VS_CHANGED;
rasterizer->particles_set_gravity_normal(p_particles,p_normal);
}
Vector3 VisualServerRaster::particles_get_gravity_normal(RID p_particles) const {
return rasterizer->particles_get_gravity_normal(p_particles);
}
void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable,float p_value) {
VS_CHANGED;
rasterizer->particles_set_variable(p_particles,p_variable,p_value);
}
float VisualServerRaster::particles_get_variable(RID p_particles, ParticleVariable p_variable) const {
return rasterizer->particles_get_variable(p_particles,p_variable);
}
void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable,float p_randomness) {
VS_CHANGED;
rasterizer->particles_set_randomness(p_particles,p_variable,p_randomness);
}
float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable) const {
return rasterizer->particles_get_randomness(p_particles,p_variable);
}
void VisualServerRaster::particles_set_color_phases(RID p_particles, int p_phases) {
VS_CHANGED;
rasterizer->particles_set_color_phases(p_particles,p_phases);
}
int VisualServerRaster::particles_get_color_phases(RID p_particles) const {
return rasterizer->particles_get_color_phases(p_particles);
}
void VisualServerRaster::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos) {
VS_CHANGED;
rasterizer->particles_set_color_phase_pos(p_particles,p_phase,p_pos);
}
float VisualServerRaster::particles_get_color_phase_pos(RID p_particles, int p_phase) const {
return rasterizer->particles_get_color_phase_pos(p_particles,p_phase);
}
void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors) {
VS_CHANGED;
rasterizer->particles_set_attractors(p_particles,p_attractors);
}
int VisualServerRaster::particles_get_attractors(RID p_particles) const {
return rasterizer->particles_get_attractors(p_particles);
}
void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos) {
VS_CHANGED;
rasterizer->particles_set_attractor_pos(p_particles,p_attractor,p_pos);
}
Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles,int p_attractor) const {
return rasterizer->particles_get_attractor_pos(p_particles,p_attractor);
}
void VisualServerRaster::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force) {
VS_CHANGED;
rasterizer->particles_set_attractor_strength(p_particles,p_attractor,p_force);
}
float VisualServerRaster::particles_get_attractor_strength(RID p_particles,int p_attractor) const {
return rasterizer->particles_get_attractor_strength(p_particles,p_attractor);
}
void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color& p_color) {
VS_CHANGED;
rasterizer->particles_set_color_phase_color(p_particles,p_phase,p_color);
}
Color VisualServerRaster::particles_get_color_phase_color(RID p_particles, int p_phase) const {
return rasterizer->particles_get_color_phase_color(p_particles,p_phase);
}
void VisualServerRaster::particles_set_material(RID p_particles, RID p_material,bool p_owned) {
VS_CHANGED;
rasterizer->particles_set_material(p_particles,p_material,p_owned);
}
RID VisualServerRaster::particles_get_material(RID p_particles) const {
return rasterizer->particles_get_material(p_particles);
}
void VisualServerRaster::particles_set_height_from_velocity(RID p_particles, bool p_enable) {
VS_CHANGED;
rasterizer->particles_set_height_from_velocity(p_particles,p_enable);
}
bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles) const {
return rasterizer->particles_has_height_from_velocity(p_particles);
}
void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
rasterizer->particles_set_use_local_coordinates(p_particles,p_enable);
}
bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles) const {
return rasterizer->particles_is_using_local_coordinates(p_particles);
}
/* Light API */
RID VisualServerRaster::light_create(LightType p_type) {
return rasterizer->light_create(p_type);
}
VisualServer::LightType VisualServerRaster::light_get_type(RID p_light) const {
return rasterizer->light_get_type(p_light);
}
void VisualServerRaster::light_set_color(RID p_light,LightColor p_type, const Color& p_color) {
VS_CHANGED;
rasterizer->light_set_color(p_light,p_type,p_color);
}
Color VisualServerRaster::light_get_color(RID p_light,LightColor p_type) const {
return rasterizer->light_get_color(p_light,p_type);
}
void VisualServerRaster::light_set_shadow(RID p_light,bool p_enabled) {
VS_CHANGED;
rasterizer->light_set_shadow(p_light,p_enabled);
}
bool VisualServerRaster::light_has_shadow(RID p_light) const {
return rasterizer->light_has_shadow(p_light);
}
void VisualServerRaster::light_set_volumetric(RID p_light,bool p_enabled) {
VS_CHANGED;
rasterizer->light_set_volumetric(p_light,p_enabled);
}
bool VisualServerRaster::light_is_volumetric(RID p_light) const {
return rasterizer->light_is_volumetric(p_light);
}
void VisualServerRaster::light_set_projector(RID p_light,RID p_texture) {
VS_CHANGED;
rasterizer->light_set_projector(p_light,p_texture);
}
RID VisualServerRaster::light_get_projector(RID p_light) const {
return rasterizer->light_get_projector(p_light);
}
void VisualServerRaster::light_set_param(RID p_light, LightParam p_var, float p_value) {
VS_CHANGED;
rasterizer->light_set_var(p_light,p_var,p_value);
_dependency_queue_update(p_light,true);
}
float VisualServerRaster::light_get_param(RID p_light, LightParam p_var) const {
return rasterizer->light_get_var(p_light,p_var);
}
void VisualServerRaster::light_set_operator(RID p_light,LightOp p_op) {
VS_CHANGED;
rasterizer->light_set_operator(p_light,p_op);
}
VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light) const {
return rasterizer->light_get_operator(p_light);
}
void VisualServerRaster::light_omni_set_shadow_mode(RID p_light,LightOmniShadowMode p_mode) {
VS_CHANGED;
rasterizer->light_omni_set_shadow_mode(p_light,p_mode);
}
VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light) const {
return rasterizer->light_omni_get_shadow_mode(p_light);
}
void VisualServerRaster::light_directional_set_shadow_mode(RID p_light,LightDirectionalShadowMode p_mode){
VS_CHANGED;
rasterizer->light_directional_set_shadow_mode(p_light,p_mode);
}
VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light) const{
return rasterizer->light_directional_get_shadow_mode(p_light);
}
void VisualServerRaster::light_directional_set_shadow_param(RID p_light,LightDirectionalShadowParam p_param, float p_value) {
VS_CHANGED;
rasterizer->light_directional_set_shadow_param(p_light,p_param,p_value);
}
float VisualServerRaster::light_directional_get_shadow_param(RID p_light,LightDirectionalShadowParam p_param) const {
return rasterizer->light_directional_get_shadow_param(p_light,p_param);
}
RID VisualServerRaster::skeleton_create() {
return rasterizer->skeleton_create();
}
void VisualServerRaster::skeleton_resize(RID p_skeleton,int p_bones) {
VS_CHANGED;
rasterizer->skeleton_resize(p_skeleton,p_bones);
}
int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton) const {
return rasterizer->skeleton_get_bone_count(p_skeleton);
}
void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform) {
VS_CHANGED;
rasterizer->skeleton_bone_set_transform(p_skeleton,p_bone,p_transform);
Map< RID, Set<Instance*> >::Element *E=skeleton_dependency_map.find(p_skeleton);
if (E) {
//detach skeletons
for (Set<Instance*>::Element *F=E->get().front();F;F=F->next()) {
_instance_queue_update( F->get() , true);
}
}
}
Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton,int p_bone) {
return rasterizer->skeleton_bone_get_transform(p_skeleton,p_bone);
}
/* VISIBILITY API */
/* ROOM API */
RID VisualServerRaster::room_create() {
Room *room = memnew( Room );
ERR_FAIL_COND_V(!room,RID());
return room_owner.make_rid( room );
}
void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree& p_bounds) {
VS_CHANGED;
Room *room = room_owner.get(p_room);
ERR_FAIL_COND(!room);
room->bounds=p_bounds;
_dependency_queue_update(p_room,true);
}
BSP_Tree VisualServerRaster::room_get_bounds(RID p_room) const {
Room *room = room_owner.get(p_room);
ERR_FAIL_COND_V(!room, BSP_Tree());
return room->bounds;
}
/* PORTAL API */
RID VisualServerRaster::portal_create() {
VS_CHANGED;
Portal *portal = memnew( Portal );
ERR_FAIL_COND_V(!portal,RID());
return portal_owner.make_rid( portal );
}
void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2>& p_shape) {
VS_CHANGED;
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND(!portal);
portal->shape=p_shape;
portal->bounds=Rect2();
for(int i=0;i<p_shape.size();i++) {
if (i==0)
portal->bounds.pos=p_shape[i];
else
portal->bounds.expand_to(p_shape[i]);
}
_dependency_queue_update(p_portal,true);
}
Vector<Point2> VisualServerRaster::portal_get_shape(RID p_portal) const {
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND_V(!portal, Vector<Point2>());
return portal->shape;
}
void VisualServerRaster::portal_set_enabled(RID p_portal, bool p_enabled) {
VS_CHANGED;
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND(!portal);
portal->enabled=p_enabled;
}
bool VisualServerRaster::portal_is_enabled(RID p_portal) const {
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND_V(!portal, false);
return portal->enabled;
}
void VisualServerRaster::portal_set_disable_distance(RID p_portal, float p_distance) {
VS_CHANGED;
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND(!portal);
portal->disable_distance=p_distance;
}
float VisualServerRaster::portal_get_disable_distance(RID p_portal) const {
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND_V(!portal, -1);
return portal->disable_distance;
}
void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color& p_color) {
VS_CHANGED;
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND(!portal);
portal->disable_color=p_color;
}
Color VisualServerRaster::portal_get_disabled_color(RID p_portal) const {
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND_V(!portal, Color());
return portal->disable_color;
}
void VisualServerRaster::portal_set_connect_range(RID p_portal, float p_range) {
VS_CHANGED;
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND(!portal);
portal->connect_range=p_range;
_dependency_queue_update(p_portal,true);
}
float VisualServerRaster::portal_get_connect_range(RID p_portal) const {
Portal *portal = portal_owner.get(p_portal);
ERR_FAIL_COND_V(!portal,0);
return portal->connect_range;
}
RID VisualServerRaster::baked_light_create() {
BakedLight *baked_light = memnew( BakedLight );
ERR_FAIL_COND_V(!baked_light,RID());
baked_light->data.mode=BAKED_LIGHT_OCTREE;
baked_light->data.octree_lattice_size=0;
baked_light->data.octree_lattice_divide=0;
baked_light->data.octree_steps=1;
baked_light->data.lightmap_multiplier=1.0;
baked_light->data.realtime_color_enabled=false;
baked_light->data.realtime_color=Color(1.0, 1.0, 1.0);
baked_light->data.realtime_energy = 1.0;
return baked_light_owner.make_rid( baked_light );
}
void VisualServerRaster::baked_light_set_mode(RID p_baked_light,BakedLightMode p_mode){
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.mode=p_mode;
baked_light->data.color_multiplier=1.0;
_dependency_queue_update(p_baked_light,true);
}
VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light) const{
const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light,BAKED_LIGHT_OCTREE);
return baked_light->data.mode;
}
void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light,float p_multiplier) {
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.lightmap_multiplier=p_multiplier;
}
float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light) const{
const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light,0);
return baked_light->data.lightmap_multiplier;
}
void VisualServerRaster::baked_light_set_octree(RID p_baked_light,const DVector<uint8_t> p_octree){
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
if (p_octree.size()==0) {
if (baked_light->data.octree_texture.is_valid())
rasterizer->free(baked_light->data.octree_texture);
baked_light->data.octree_texture=RID();
baked_light->octree_aabb=AABB();
baked_light->octree_tex_size=Size2();
} else {
int tex_w;
int tex_h;
int light_tex_w;
int light_tex_h;
bool is16;
bool has_light_tex=false;
{
DVector<uint8_t>::Read r=p_octree.read();
tex_w = decode_uint32(&r[0]);
tex_h = decode_uint32(&r[4]);
print_line("TEX W: "+itos(tex_w)+" TEX H:"+itos(tex_h)+" LEN: "+itos(p_octree.size()));
is16=decode_uint32(&r[8]);
baked_light->data.octree_lattice_size=decode_float(&r[12]);
baked_light->data.octree_lattice_divide=tex_w/4.0;
print_line("LATTICE SIZE: "+rtos(baked_light->data.octree_lattice_size));
print_line("LATTICE DIVIDE: "+rtos(baked_light->data.octree_lattice_divide));
baked_light->data.octree_steps=decode_uint32(&r[16]);
baked_light->data.octree_tex_pixel_size.x=1.0/tex_w;
baked_light->data.octree_tex_pixel_size.y=1.0/tex_h;
baked_light->data.texture_multiplier=decode_uint32(&r[20]);
light_tex_w=decode_uint16(&r[24]);
light_tex_h=decode_uint16(&r[26]);
print_line("ltexw "+itos(light_tex_w));
print_line("ltexh "+itos(light_tex_h));
if (light_tex_w>0 && light_tex_h>0) {
baked_light->data.light_tex_pixel_size.x=1.0/light_tex_w;
baked_light->data.light_tex_pixel_size.y=1.0/light_tex_h;
has_light_tex=true;
} else {
baked_light->data.light_tex_pixel_size=baked_light->data.octree_tex_pixel_size;
}
baked_light->octree_aabb.pos.x=decode_float(&r[32]);
baked_light->octree_aabb.pos.y=decode_float(&r[36]);
baked_light->octree_aabb.pos.z=decode_float(&r[40]);
baked_light->octree_aabb.size.x=decode_float(&r[44]);
baked_light->octree_aabb.size.y=decode_float(&r[48]);
baked_light->octree_aabb.size.z=decode_float(&r[52]);
}
if (baked_light->data.octree_texture.is_valid()) {
if (tex_w!=baked_light->octree_tex_size.x || tex_h!=baked_light->octree_tex_size.y) {
rasterizer->free(baked_light->data.octree_texture);
baked_light->data.octree_texture=RID();
baked_light->octree_tex_size.x=0;
baked_light->octree_tex_size.y=0;
}
}
if (baked_light->data.light_texture.is_valid()) {
if (!has_light_tex || light_tex_w!=baked_light->light_tex_size.x || light_tex_h!=baked_light->light_tex_size.y) {
rasterizer->free(baked_light->data.light_texture);
baked_light->data.light_texture=RID();
baked_light->light_tex_size.x=0;
baked_light->light_tex_size.y=0;
}
}
if (!baked_light->data.octree_texture.is_valid()) {
baked_light->data.octree_texture=rasterizer->texture_create();
rasterizer->texture_allocate(baked_light->data.octree_texture,tex_w,tex_h,Image::FORMAT_RGBA,TEXTURE_FLAG_FILTER);
baked_light->octree_tex_size.x=tex_w;
baked_light->octree_tex_size.y=tex_h;
}
if (!baked_light->data.light_texture.is_valid() && has_light_tex) {
baked_light->data.light_texture=rasterizer->texture_create();
rasterizer->texture_allocate(baked_light->data.light_texture,light_tex_w,light_tex_h,Image::FORMAT_RGBA,TEXTURE_FLAG_FILTER);
baked_light->light_tex_size.x=light_tex_w;
baked_light->light_tex_size.y=light_tex_h;
}
Image img(tex_w,tex_h,0,Image::FORMAT_RGBA,p_octree);
rasterizer->texture_set_data(baked_light->data.octree_texture,img);
}
_dependency_queue_update(p_baked_light,true);
}
DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light) const{
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light,DVector<uint8_t>());
if (rasterizer->is_texture(baked_light->data.octree_texture)) {
Image img = rasterizer->texture_get_data(baked_light->data.octree_texture);
return img.get_data();
} else {
return DVector<uint8_t>();
}
}
void VisualServerRaster::baked_light_set_light(RID p_baked_light,const DVector<uint8_t> p_light) {
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
ERR_FAIL_COND(p_light.size()==0);
int tex_w=baked_light->light_tex_size.x;
int tex_h=baked_light->light_tex_size.y;
ERR_FAIL_COND(tex_w==0 && tex_h==0);
ERR_FAIL_COND(!baked_light->data.light_texture.is_valid());
print_line("w: "+itos(tex_w)+" h: "+itos(tex_h)+" lightsize: "+itos(p_light.size()));
Image img(tex_w,tex_h,0,Image::FORMAT_RGBA,p_light);
rasterizer->texture_set_data(baked_light->data.light_texture,img);
}
DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light) const{
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light,DVector<uint8_t>());
if (rasterizer->is_texture(baked_light->data.light_texture)) {
Image img = rasterizer->texture_get_data(baked_light->data.light_texture);
return img.get_data();
} else {
return DVector<uint8_t>();
}
}
void VisualServerRaster::baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler) {
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->sampler=p_sampler;
}
DVector<int> VisualServerRaster::baked_light_get_sampler_octree(RID p_baked_light) const {
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light,DVector<int>());
return baked_light->sampler;
}
void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light,const RID p_texture,int p_id){
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.lightmaps.insert(p_id,p_texture);
}
void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light){
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.lightmaps.clear();
}
void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled) {
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.realtime_color_enabled = p_enabled;
}
bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light) const{
const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light, false);
return baked_light->data.realtime_color_enabled;
}
void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color& p_color) {
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.realtime_color = p_color;
}
Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light) const{
const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light, Color(1.0, 1.0, 1.0));
return baked_light->data.realtime_color;
}
void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, const float p_energy) {
VS_CHANGED;
BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND(!baked_light);
baked_light->data.realtime_energy = p_energy;
}
float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light) const{
const BakedLight *baked_light = baked_light_owner.get(p_baked_light);
ERR_FAIL_COND_V(!baked_light, 1.0f);
return baked_light->data.realtime_energy;
}
/* BAKED LIGHT SAMPLER */
RID VisualServerRaster::baked_light_sampler_create() {
BakedLightSampler * blsamp = memnew( BakedLightSampler );
RID rid = baked_light_sampler_owner.make_rid(blsamp);
_update_baked_light_sampler_dp_cache(blsamp);
return rid;
}
void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param,float p_value){
VS_CHANGED;
BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
ERR_FAIL_COND(!blsamp);
ERR_FAIL_INDEX(p_param,BAKED_LIGHT_SAMPLER_MAX);
blsamp->params[p_param]=p_value;
_dependency_queue_update(p_baked_light_sampler,true);
}
float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler,BakedLightSamplerParam p_param) const{
BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
ERR_FAIL_COND_V(!blsamp,0);
ERR_FAIL_INDEX_V(p_param,BAKED_LIGHT_SAMPLER_MAX,0);
return blsamp->params[p_param];
}
void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler * blsamp) {
int res = blsamp->resolution;
blsamp->dp_cache.resize(res*res*2);
Vector3 *dp_normals=blsamp->dp_cache.ptr();
for(int p=0;p<2;p++) {
float sign = p==0?1:-1;
int ofs = res*res*p;
for(int i=0;i<res;i++) {
for(int j=0;j<res;j++) {
Vector2 v(
(i/float(res))*2.0-1.0,
(j/float(res))*2.0-1.0
);
float l=v.length();
if (l>1.0) {
v/=l;
l=1.0; //clamp to avoid imaginary
}
v*=(2*l)/(l*l+1); //inverse of the dual paraboloid function
Vector3 n = Vector3(v.x,v.y,sign*sqrtf(MAX(1 - v.dot(v),0))); //reconstruction of z
n.y*=sign;
dp_normals[j*res+i+ofs]=n;
}
}
}
}
void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler,int p_resolution){
ERR_FAIL_COND(p_resolution<4 || p_resolution>64);
VS_CHANGED;
BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
ERR_FAIL_COND(!blsamp);
blsamp->resolution=p_resolution;
_update_baked_light_sampler_dp_cache(blsamp);
}
int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler) const{
BakedLightSampler * blsamp = baked_light_sampler_owner.get(p_baked_light_sampler);
ERR_FAIL_COND_V(!blsamp,0);
return blsamp->resolution;
}
/* CAMERA API */
RID VisualServerRaster::camera_create() {
Camera * camera = memnew( Camera );
return camera_owner.make_rid( camera );
}
void VisualServerRaster::camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far) {
VS_CHANGED
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->type=Camera::PERSPECTIVE;
camera->fov=p_fovy_degrees;
camera->znear=p_z_near;
camera->zfar=p_z_far;
}
void VisualServerRaster::camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far) {
VS_CHANGED;
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->type=Camera::ORTHOGONAL;
camera->size=p_size;
camera->znear=p_z_near;
camera->zfar=p_z_far;
}
void VisualServerRaster::camera_set_transform(RID p_camera,const Transform& p_transform) {
VS_CHANGED;
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->transform=p_transform.orthonormalized();
}
void VisualServerRaster::camera_set_visible_layers(RID p_camera,uint32_t p_layers) {
VS_CHANGED;
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->visible_layers=p_layers;
}
uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera) const{
const Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND_V(!camera,0);
return camera->visible_layers;
}
void VisualServerRaster::camera_set_environment(RID p_camera,RID p_env) {
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->env=p_env;
}
RID VisualServerRaster::camera_get_environment(RID p_camera) const {
const Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND_V(!camera,RID());
return camera->env;
}
void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera,bool p_enable) {
Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND(!camera);
camera->vaspect=p_enable;
}
bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera,bool p_enable) const{
const Camera *camera = camera_owner.get( p_camera );
ERR_FAIL_COND_V(!camera,false);
return camera->vaspect;
}
/* VIEWPORT API */
RID VisualServerRaster::viewport_create() {
Viewport *viewport = memnew( Viewport );
RID rid = viewport_owner.make_rid( viewport );
ERR_FAIL_COND_V( !rid.is_valid(), rid );
viewport->self=rid;
viewport->hide_scenario=false;
viewport->hide_canvas=false;
viewport->viewport_data=rasterizer->viewport_data_create();
return rid;
}
void VisualServerRaster::viewport_attach_to_screen(RID p_viewport,int p_screen) {
VS_CHANGED;
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
screen_viewports[p_viewport]=p_screen;
}
void VisualServerRaster::viewport_detach(RID p_viewport) {
VS_CHANGED;
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
ERR_FAIL_COND(!screen_viewports.has(p_viewport));
screen_viewports.erase(p_viewport);
}
void VisualServerRaster::viewport_set_as_render_target(RID p_viewport,bool p_enable) {
VS_CHANGED;
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
if (viewport->render_target.is_valid()==p_enable)
return;
if (!p_enable) {
rasterizer->free(viewport->render_target);
viewport->render_target=RID();
viewport->render_target_texture=RID();
if (viewport->update_list.in_list())
viewport_update_list.remove(&viewport->update_list);
} else {
viewport->render_target=rasterizer->render_target_create();
rasterizer->render_target_set_size(viewport->render_target,viewport->rect.width,viewport->rect.height);
viewport->render_target_texture=rasterizer->render_target_get_texture(viewport->render_target);
if (viewport->render_target_update_mode!=RENDER_TARGET_UPDATE_DISABLED)
viewport_update_list.add(&viewport->update_list);
}
}
void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport,RenderTargetUpdateMode p_mode){
VS_CHANGED;
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
if (viewport->render_target.is_valid() && viewport->update_list.in_list())
viewport_update_list.remove(&viewport->update_list);
viewport->render_target_update_mode=p_mode;
if (viewport->render_target.is_valid() &&viewport->render_target_update_mode!=RENDER_TARGET_UPDATE_DISABLED)
viewport_update_list.add(&viewport->update_list);
}
VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport) const{
const Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,RENDER_TARGET_UPDATE_DISABLED);
return viewport->render_target_update_mode;
}
RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport) const{
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,RID());
return viewport->render_target_texture;
}
void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport,bool p_enable) {
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->render_target_vflip=p_enable;
}
void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport,bool p_enable) {
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->render_target_clear_on_new_frame=p_enable;
}
void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport,const Rect2& p_rect) {
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->rt_to_screen_rect=p_rect;
}
bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport) const{
const Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,false);
return viewport->render_target_vflip;
}
bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport) const{
const Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,false);
return viewport->render_target_clear_on_new_frame;
}
void VisualServerRaster::viewport_render_target_clear(RID p_viewport) {
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->render_target_clear=true;
}
void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport) {
VS_CHANGED;
Viewport *viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->queue_capture=true;
}
Image VisualServerRaster::viewport_get_screen_capture(RID p_viewport) const {
Viewport *viewport = (Viewport*)viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,Image());
Image ret = viewport->capture;
viewport->capture=Image();
return ret;
}
void VisualServerRaster::viewport_set_rect(RID p_viewport,const ViewportRect& p_rect) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->rect=p_rect;
if (viewport->render_target.is_valid()) {
rasterizer->render_target_set_size(viewport->render_target,viewport->rect.width,viewport->rect.height);
}
}
VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport) const {
const Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport, ViewportRect());
return viewport->rect;
}
void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport,bool p_hide) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->hide_scenario=p_hide;
}
void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport,bool p_hide) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->hide_canvas=p_hide;
}
void VisualServerRaster::viewport_set_disable_environment(RID p_viewport,bool p_disable) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->disable_environment=p_disable;
}
void VisualServerRaster::viewport_attach_camera(RID p_viewport,RID p_camera) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
if (p_camera.is_valid()) {
ERR_FAIL_COND(!camera_owner.owns(p_camera));
// a camera
viewport->camera=p_camera;
} else {
viewport->camera=RID();
}
}
void VisualServerRaster::viewport_set_scenario(RID p_viewport,RID p_scenario) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
if (p_scenario.is_valid()) {
ERR_FAIL_COND(!scenario_owner.owns(p_scenario));
// a camera
viewport->scenario=p_scenario;
} else {
viewport->scenario=RID();
}
}
RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport) const {
const Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport, RID());
return viewport->camera;
}
void VisualServerRaster::viewport_attach_canvas(RID p_viewport,RID p_canvas) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
Canvas *canvas = canvas_owner.get( p_canvas );
ERR_FAIL_COND(!canvas);
ERR_EXPLAIN("Canvas already attached.");
ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
Viewport::CanvasData cd;
cd.canvas=canvas;
cd.layer=0;
viewport->canvas_map[p_canvas]=cd;
canvas->viewports.insert(p_viewport);
}
void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport,RID p_canvas,const Matrix32& p_transform) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
if (!E) {
ERR_EXPLAIN("Viewport does not contain the canvas");
ERR_FAIL_COND(!E);
}
E->get().transform=p_transform;
}
Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport,RID p_canvas) const {
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,Matrix32());
Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
if (!E) {
ERR_EXPLAIN("Viewport does not contain the canvas");
ERR_FAIL_COND_V(!E,Matrix32());
}
return E->get().transform;
}
void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport,const Matrix32& p_transform) {
VS_CHANGED
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->global_transform=p_transform;
}
Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport) const{
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport,Matrix32());
return viewport->global_transform;
}
void VisualServerRaster::viewport_remove_canvas(RID p_viewport,RID p_canvas) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
Canvas *canvas = canvas_owner.get( p_canvas );
ERR_FAIL_COND(!canvas);
Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
if (!E) {
ERR_EXPLAIN("Viewport does not contain the canvas");
ERR_FAIL_COND(!E);
}
canvas->viewports.erase(p_viewport);
viewport->canvas_map.erase(E);
}
void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport,RID p_canvas,int p_layer) {
VS_CHANGED;
Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
Map<RID,Viewport::CanvasData>::Element *E=viewport->canvas_map.find(p_canvas);
if (!E) {
ERR_EXPLAIN("Viewport does not contain the canvas");
ERR_FAIL_COND(!E);
}
E->get().layer=p_layer;
}
void VisualServerRaster::viewport_set_transparent_background(RID p_viewport,bool p_enabled) {
VS_CHANGED;
Viewport *viewport=viewport_owner.get( p_viewport );
ERR_FAIL_COND(!viewport);
viewport->transparent_bg=p_enabled;
}
bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport) const {
Viewport *viewport=viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport, false);
return viewport->transparent_bg;
}
RID VisualServerRaster::viewport_get_scenario(RID p_viewport) const {
const Viewport *viewport=NULL;
viewport = viewport_owner.get( p_viewport );
ERR_FAIL_COND_V(!viewport, RID());
return viewport->scenario;
}
RID VisualServerRaster::environment_create() {
return rasterizer->environment_create();
}
void VisualServerRaster::environment_set_background(RID p_env,EnvironmentBG p_bg){
rasterizer->environment_set_background(p_env,p_bg);
}
VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env) const{
return rasterizer->environment_get_background(p_env);
}
void VisualServerRaster::environment_set_background_param(RID p_env,EnvironmentBGParam p_param, const Variant& p_value){
rasterizer->environment_set_background_param(p_env,p_param,p_value);
}
Variant VisualServerRaster::environment_get_background_param(RID p_env,EnvironmentBGParam p_param) const{
return rasterizer->environment_get_background_param(p_env,p_param);
}
void VisualServerRaster::environment_set_enable_fx(RID p_env,EnvironmentFx p_effect,bool p_enabled){
rasterizer->environment_set_enable_fx(p_env,p_effect,p_enabled);
}
bool VisualServerRaster::environment_is_fx_enabled(RID p_env,EnvironmentFx p_effect) const{
return rasterizer->environment_is_fx_enabled(p_env,p_effect);
}
void VisualServerRaster::environment_fx_set_param(RID p_env,EnvironmentFxParam p_param,const Variant& p_value){
rasterizer->environment_fx_set_param(p_env,p_param,p_value);
}
Variant VisualServerRaster::environment_fx_get_param(RID p_env,EnvironmentFxParam p_param) const {
return environment_fx_get_param(p_env,p_param);
}
/* SCENARIO API */
void VisualServerRaster::_dependency_queue_update(RID p_rid,bool p_update_aabb,bool p_update_materials) {
Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
if (!E)
return;
Set<RID>::Element *I = E->get().front();
while(I) {
Instance *ins = instance_owner.get( I->get() );
_instance_queue_update( ins , p_update_aabb, p_update_materials );
I = I->next();
}
}
void VisualServerRaster::_instance_queue_update(Instance *p_instance,bool p_update_aabb,bool p_update_materials) {
if (p_update_aabb)
p_instance->update_aabb=true;
if (p_update_materials)
p_instance->update_materials=true;
if (p_instance->update)
return;
p_instance->update_next=instance_update_list;
instance_update_list=p_instance;
p_instance->update=true;
}
RID VisualServerRaster::scenario_create() {
Scenario *scenario = memnew( Scenario );
ERR_FAIL_COND_V(!scenario,RID());
RID scenario_rid = scenario_owner.make_rid( scenario );
scenario->self=scenario_rid;
scenario->octree.set_pair_callback(instance_pair,this);
scenario->octree.set_unpair_callback(instance_unpair,this);
return scenario_rid;
}
void VisualServerRaster::scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode) {
VS_CHANGED;
Scenario *scenario = scenario_owner.get(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->debug=p_debug_mode;
}
void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment) {
VS_CHANGED;
Scenario *scenario = scenario_owner.get(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->environment=p_environment;
}
void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
VS_CHANGED;
Scenario *scenario = scenario_owner.get(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->fallback_environment=p_environment;
}
RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const{
const Scenario *scenario = scenario_owner.get(p_scenario);
ERR_FAIL_COND_V(!scenario,RID());
return scenario->environment;
}
/* INSTANCING API */
RID VisualServerRaster::instance_create() {
Instance *instance = memnew( Instance );
ERR_FAIL_COND_V(!instance,RID());
RID instance_rid = instance_owner.make_rid(instance);
instance->self=instance_rid;
instance->base_type=INSTANCE_NONE;
instance->scenario=NULL;
return instance_rid;
}
void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->base_type!=INSTANCE_NONE) {
//free anything related to that base
Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( instance->base_rid );
if (E) {
// wtf, no E?
E->get().erase( instance->self );
} else {
ERR_PRINT("no base E? Bug?");
}
if ( instance->room ) {
instance_set_room(p_instance,RID());
/*
if((1<<instance->base_type)&INSTANCE_GEOMETRY_MASK)
instance->room->room_info->owned_geometry_instances.erase(instance->RE);
else if (instance->base_type==INSTANCE_PORTAL) {
print_line("freeing portal, is it there? "+itos(instance->room->room_info->owned_portal_instances.(instance->RE)));
instance->room->room_info->owned_portal_instances.erase(instance->RE);
} else if (instance->base_type==INSTANCE_ROOM)
instance->room->room_info->owned_room_instances.erase(instance->RE);
else if (instance->base_type==INSTANCE_LIGHT)
instance->room->room_info->owned_light_instances.erase(instance->RE);
instance->RE=NULL;*/
}
if (instance->light_info) {
if (instance->scenario && instance->light_info->D)
instance->scenario->directional_lights.erase( instance->light_info->D );
rasterizer->free(instance->light_info->instance);
memdelete(instance->light_info);
instance->light_info=NULL;
}
if (instance->portal_info) {
_portal_disconnect(instance,true);
memdelete(instance->portal_info);
instance->portal_info=NULL;
}
if (instance->baked_light_info) {
while(instance->baked_light_info->owned_instances.size()) {
Instance *owned=instance->baked_light_info->owned_instances.front()->get();
owned->baked_light=NULL;
owned->data.baked_light=NULL;
owned->data.baked_light_octree_xform=NULL;
owned->BLE=NULL;
instance->baked_light_info->owned_instances.pop_front();
}
memdelete(instance->baked_light_info);
instance->baked_light_info=NULL;
}
if (instance->scenario && instance->octree_id) {
instance->scenario->octree.erase( instance->octree_id );
instance->octree_id=0;
}
if (instance->room_info) {
for(List<Instance*>::Element *E=instance->room_info->owned_geometry_instances.front();E;E=E->next()) {
Instance *owned = E->get();
owned->room=NULL;
owned->RE=NULL;
}
for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next()) {
_portal_disconnect(E->get(),true);
Instance *owned = E->get();
owned->room=NULL;
owned->RE=NULL;
}
for(List<Instance*>::Element *E=instance->room_info->owned_room_instances.front();E;E=E->next()) {
Instance *owned = E->get();
owned->room=NULL;
owned->RE=NULL;
}
if (instance->room_info->disconnected_child_portals.size()) {
ERR_PRINT("BUG: Disconnected portals remain!");
}
memdelete(instance->room_info);
instance->room_info=NULL;
}
if (instance->particles_info) {
rasterizer->free( instance->particles_info->instance );
memdelete(instance->particles_info);
instance->particles_info=NULL;
}
if (instance->baked_light_sampler_info) {
while (instance->baked_light_sampler_info->owned_instances.size()) {
instance_geometry_set_baked_light_sampler(instance->baked_light_sampler_info->owned_instances.front()->get()->self,RID());
}
if (instance->baked_light_sampler_info->sampled_light.is_valid()) {
rasterizer->free(instance->baked_light_sampler_info->sampled_light);
}
memdelete( instance->baked_light_sampler_info );
instance->baked_light_sampler_info=NULL;
}
instance->data.morph_values.clear();
instance->data.materials.clear();
}
instance->base_type=INSTANCE_NONE;
instance->base_rid=RID();
if (p_base.is_valid()) {
if (rasterizer->is_mesh(p_base)) {
instance->base_type=INSTANCE_MESH;
instance->data.morph_values.resize( rasterizer->mesh_get_morph_target_count(p_base));
instance->data.materials.resize( rasterizer->mesh_get_surface_count(p_base));
} else if (rasterizer->is_multimesh(p_base)) {
instance->base_type=INSTANCE_MULTIMESH;
} else if (rasterizer->is_immediate(p_base)) {
instance->base_type=INSTANCE_IMMEDIATE;
} else if (rasterizer->is_particles(p_base)) {
instance->base_type=INSTANCE_PARTICLES;
instance->particles_info=memnew( Instance::ParticlesInfo );
instance->particles_info->instance = rasterizer->particles_instance_create( p_base );
} else if (rasterizer->is_light(p_base)) {
instance->base_type=INSTANCE_LIGHT;
instance->light_info = memnew( Instance::LightInfo );
instance->light_info->instance = rasterizer->light_instance_create(p_base);
if (instance->scenario && rasterizer->light_get_type(p_base)==LIGHT_DIRECTIONAL) {
instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
}
} else if (room_owner.owns(p_base)) {
instance->base_type=INSTANCE_ROOM;
instance->room_info = memnew( Instance::RoomInfo );
instance->room_info->room=room_owner.get(p_base);
} else if (portal_owner.owns(p_base)) {
instance->base_type=INSTANCE_PORTAL;
instance->portal_info = memnew(Instance::PortalInfo);
instance->portal_info->portal=portal_owner.get(p_base);
} else if (baked_light_owner.owns(p_base)) {
instance->base_type=INSTANCE_BAKED_LIGHT;
instance->baked_light_info=memnew(Instance::BakedLightInfo);
instance->baked_light_info->baked_light=baked_light_owner.get(p_base);
//instance->portal_info = memnew(Instance::PortalInfo);
//instance->portal_info->portal=portal_owner.get(p_base);
} else if (baked_light_sampler_owner.owns(p_base)) {
instance->base_type=INSTANCE_BAKED_LIGHT_SAMPLER;
instance->baked_light_sampler_info=memnew( Instance::BakedLightSamplerInfo);
instance->baked_light_sampler_info->sampler=baked_light_sampler_owner.get(p_base);
//instance->portal_info = memnew(Instance::PortalInfo);
//instance->portal_info->portal=portal_owner.get(p_base);
} else {
ERR_EXPLAIN("Invalid base RID for instance!")
ERR_FAIL();
}
instance_dependency_map[ p_base ].insert( instance->self );
instance->base_rid=p_base;
if (instance->scenario)
_instance_queue_update(instance,true);
}
}
RID VisualServerRaster::instance_get_base(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, RID() );
return instance->base_rid;
}
void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->scenario) {
Map< RID, Set<RID> >::Element *E = instance_dependency_map.find( instance->scenario->self );
if (E) {
// wtf, no E?
E->get().erase( instance->self );
} else {
ERR_PRINT("no scenario E? Bug?");
}
if (instance->light_info) {
if (instance->light_info->D)
instance->scenario->directional_lights.erase( instance->light_info->D );
}
if (instance->portal_info) {
_portal_disconnect(instance,true);
}
if (instance->octree_id) {
instance->scenario->octree.erase( instance->octree_id );
instance->octree_id=0;
}
instance->scenario=NULL;
}
if (p_scenario.is_valid()) {
Scenario *scenario = scenario_owner.get( p_scenario );
ERR_FAIL_COND(!scenario);
instance->scenario=scenario;
instance_dependency_map[ p_scenario ].insert( instance->self );
instance->scenario=scenario;
if (instance->base_type==INSTANCE_LIGHT && rasterizer->light_get_type(instance->base_rid)==LIGHT_DIRECTIONAL) {
instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
}
_instance_queue_update(instance,true);
}
}
RID VisualServerRaster::instance_get_scenario(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, RID() );
if (instance->scenario)
return instance->scenario->self;
else
return RID();
}
void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->layer_mask=p_mask;
}
uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance) const{
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, 0 );
return instance->layer_mask;
}
AABB VisualServerRaster::instance_get_base_aabb(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, AABB() );
return instance->aabb;
}
void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance,uint32_t p_ID) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->object_ID=p_ID;
}
uint32_t VisualServerRaster::instance_get_object_instance_ID(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, 0 );
return instance->object_ID;
}
void VisualServerRaster::instance_attach_skeleton(RID p_instance,RID p_skeleton) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->data.skeleton.is_valid()) {
skeleton_dependency_map[instance->data.skeleton].erase(instance);
}
instance->data.skeleton=p_skeleton;
if (instance->data.skeleton.is_valid()) {
skeleton_dependency_map[instance->data.skeleton].insert(instance);
}
}
RID VisualServerRaster::instance_get_skeleton(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, RID() );
return instance->data.skeleton;
}
void VisualServerRaster::instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
ERR_FAIL_INDEX( p_shape, instance->data.morph_values.size() );
instance->data.morph_values[p_shape]=p_weight;
}
float VisualServerRaster::instance_get_morph_target_weight(RID p_instance,int p_shape) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, 0 );
ERR_FAIL_INDEX_V( p_shape, instance->data.morph_values.size(), 0 );
return instance->data.morph_values[p_shape];
}
void VisualServerRaster::instance_set_surface_material(RID p_instance,int p_surface, RID p_material) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance);
ERR_FAIL_INDEX( p_surface, instance->data.materials.size() );
instance->data.materials[p_surface]=p_material;
}
void VisualServerRaster::instance_set_transform(RID p_instance, const Transform& p_transform) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (p_transform==instance->data.transform) // must improve somehow
return;
instance->data.transform=p_transform;
if (instance->base_type==INSTANCE_LIGHT)
instance->data.transform.orthonormalize();
_instance_queue_update(instance);
}
Transform VisualServerRaster::instance_get_transform(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, Transform() );
return instance->data.transform;
}
void VisualServerRaster::instance_set_exterior( RID p_instance, bool p_enabled ) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
ERR_EXPLAIN("Portals can't be assigned to be exterior");
ERR_FAIL_COND( instance->base_type == INSTANCE_PORTAL );
if (instance->exterior==p_enabled)
return;
instance->exterior=p_enabled;
_instance_queue_update( instance );
}
bool VisualServerRaster::instance_is_exterior( RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, false );
return instance->exterior;
}
void VisualServerRaster::instance_set_room( RID p_instance, RID p_room ) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->room && instance->RE) {
//instance already havs a room, remove it from there
if ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK ) {
instance->room->room_info->owned_geometry_instances.erase(instance->RE);
if (!p_room.is_valid() && instance->octree_id) {
//remove from the octree, so it's re-added with different flags
instance->scenario->octree.erase( instance->octree_id );
instance->octree_id=0;
_instance_queue_update( instance,true );
}
} else if ( instance->base_type==INSTANCE_ROOM ) {
instance->room->room_info->owned_room_instances.erase(instance->RE);
for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next()) {
_portal_disconnect(E->get());
_instance_queue_update( E->get(),false );
}
} else if ( instance->base_type==INSTANCE_PORTAL ) {
_portal_disconnect(instance,true);
bool ss = instance->room->room_info->owned_portal_instances.erase(instance->RE);
} else if ( instance->base_type==INSTANCE_LIGHT ) {
instance->room->room_info->owned_light_instances.erase(instance->RE);
} else {
ERR_FAIL();
}
instance->RE=NULL;
instance->room=NULL;
} else {
if (p_room.is_valid() && instance->octree_id) {
//remove from the octree, so it's re-added with different flags
instance->scenario->octree.erase( instance->octree_id );
instance->octree_id=0;
_instance_queue_update( instance,true );
}
}
if (!p_room.is_valid())
return; // just clearning the room
Instance *room = instance_owner.get( p_room );
ERR_FAIL_COND( !room );
ERR_FAIL_COND( room->base_type!=INSTANCE_ROOM );
if (instance->base_type==INSTANCE_ROOM) {
//perform cycle test
Instance *parent = instance;
while(parent) {
ERR_EXPLAIN("Cycle in room assignment");
ERR_FAIL_COND( parent == room );
parent=parent->room;
}
}
if ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK ) {
instance->RE = room->room_info->owned_geometry_instances.push_back(instance);
} else if ( instance->base_type==INSTANCE_ROOM ) {
instance->RE = room->room_info->owned_room_instances.push_back(instance);
for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next())
_instance_queue_update( E->get(),false );
} else if ( instance->base_type==INSTANCE_PORTAL ) {
instance->RE = room->room_info->owned_portal_instances.push_back(instance);
} else if ( instance->base_type==INSTANCE_LIGHT ) {
instance->RE = room->room_info->owned_light_instances.push_back(instance);
} else {
ERR_FAIL();
}
instance->room=room;
}
RID VisualServerRaster::instance_get_room( RID p_instance ) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, RID() );
if (instance->room)
return instance->room->self;
else
return RID();
}
void VisualServerRaster::instance_set_extra_visibility_margin( RID p_instance, real_t p_margin ) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->extra_margin=p_margin;
}
real_t VisualServerRaster::instance_get_extra_visibility_margin( RID p_instance ) const{
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, 0 );
return instance->extra_margin;
}
Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB& p_aabb, RID p_scenario) const {
Vector<RID> instances;
Scenario *scenario=scenario_owner.get(p_scenario);
ERR_FAIL_COND_V(!scenario,instances);
const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
int culled=0;
Instance *cull[1024];
culled=scenario->octree.cull_AABB(p_aabb,cull,1024);
for (int i=0;i<culled;i++) {
Instance *instance=cull[i];
ERR_CONTINUE(!instance);
instances.push_back(instance->self);
}
return instances;
}
Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario) const{
Vector<RID> instances;
Scenario *scenario=scenario_owner.get(p_scenario);
ERR_FAIL_COND_V(!scenario,instances);
const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
int culled=0;
Instance *cull[1024];
culled=scenario->octree.cull_segment(p_from,p_to*10000,cull,1024);
for (int i=0;i<culled;i++) {
Instance *instance=cull[i];
ERR_CONTINUE(!instance);
instances.push_back(instance->self);
}
return instances;
}
Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane>& p_convex, RID p_scenario) const{
Vector<RID> instances;
Scenario *scenario=scenario_owner.get(p_scenario);
ERR_FAIL_COND_V(!scenario,instances);
const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
int culled=0;
Instance *cull[1024];
culled=scenario->octree.cull_convex(p_convex,cull,1024);
for (int i=0;i<culled;i++) {
Instance *instance=cull[i];
ERR_CONTINUE(!instance);
instances.push_back(instance->self);
}
return instances;
}
void VisualServerRaster::instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled) {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
// ERR_FAIL_COND( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK) );
switch(p_flags) {
case INSTANCE_FLAG_VISIBLE: {
instance->visible=p_enabled;
} break;
case INSTANCE_FLAG_BILLBOARD: {
instance->data.billboard=p_enabled;
} break;
case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
instance->data.billboard_y=p_enabled;
} break;
case INSTANCE_FLAG_CAST_SHADOW: {
if (p_enabled == true) {
instance->data.cast_shadows = SHADOW_CASTING_SETTING_ON;
}
else {
instance->data.cast_shadows = SHADOW_CASTING_SETTING_OFF;
}
} break;
case INSTANCE_FLAG_RECEIVE_SHADOWS: {
instance->data.receive_shadows=p_enabled;
} break;
case INSTANCE_FLAG_DEPH_SCALE: {
instance->data.depth_scale=p_enabled;
} break;
case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
instance->visible_in_all_rooms=p_enabled;
} break;
}
}
bool VisualServerRaster::instance_geometry_get_flag(RID p_instance,InstanceFlags p_flags) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, false );
// ERR_FAIL_COND_V( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK), false );
switch(p_flags) {
case INSTANCE_FLAG_VISIBLE: {
return instance->visible;
} break;
case INSTANCE_FLAG_BILLBOARD: {
return instance->data.billboard;
} break;
case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
return instance->data.billboard_y;
} break;
case INSTANCE_FLAG_CAST_SHADOW: {
if(instance->data.cast_shadows == SHADOW_CASTING_SETTING_OFF) {
return false;
}
else {
return true;
}
} break;
case INSTANCE_FLAG_RECEIVE_SHADOWS: {
return instance->data.receive_shadows;
} break;
case INSTANCE_FLAG_DEPH_SCALE: {
return instance->data.depth_scale;
} break;
case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
return instance->visible_in_all_rooms;
} break;
}
return false;
}
void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting) {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->data.cast_shadows = p_shadow_casting_setting;
}
VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, SHADOW_CASTING_SETTING_OFF );
return instance->data.cast_shadows;
}
void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->data.material_override=p_material;
}
RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance) const{
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance, RID() );
return instance->data.material_override;
}
void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max){
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->draw_range_begin=p_min;
instance->draw_range_end=p_max;
}
float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,0 );
return instance->draw_range_begin;
}
float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,0 );
return instance->draw_range_end;
}
void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance,RID p_baked_light) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->baked_light) {
instance->baked_light->baked_light_info->owned_instances.erase(instance->BLE);
instance->BLE=NULL;
instance->baked_light=NULL;
instance->data.baked_light=NULL;
instance->data.baked_light_octree_xform=NULL;
}
if (!p_baked_light.is_valid())
return;
Instance *bl_instance = instance_owner.get( p_baked_light );
ERR_FAIL_COND( !bl_instance );
ERR_FAIL_COND( bl_instance->base_type!=INSTANCE_BAKED_LIGHT );
instance->baked_light=bl_instance;
instance->BLE=bl_instance->baked_light_info->owned_instances.push_back(instance);
instance->data.baked_light=&bl_instance->baked_light_info->baked_light->data;
instance->data.baked_light_octree_xform=&bl_instance->baked_light_info->affine_inverse;
}
RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,RID() );
if (instance->baked_light)
return instance->baked_light->self;
return RID();
}
void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance,RID p_baked_light_sampler) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
if (instance->sampled_light) {
instance->sampled_light->baked_light_sampler_info->owned_instances.erase(instance);
instance->data.sampled_light=RID();
}
if(p_baked_light_sampler.is_valid()) {
Instance *sampler_instance = instance_owner.get( p_baked_light_sampler );
ERR_FAIL_COND( !sampler_instance );
ERR_FAIL_COND( sampler_instance->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER );
instance->sampled_light=sampler_instance;
instance->sampled_light->baked_light_sampler_info->owned_instances.insert(instance);
} else {
instance->sampled_light=NULL;
}
instance->data.sampled_light=RID();
}
RID VisualServerRaster::instance_geometry_get_baked_light_sampler(RID p_instance) const {
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,RID() );
if (instance->sampled_light)
return instance->sampled_light->self;
else
return RID();
}
void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance,int p_tex_id){
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
instance->data.baked_lightmap_id=p_tex_id;
}
int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance) const{
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,0 );
return instance->data.baked_lightmap_id;
}
void VisualServerRaster::_update_instance(Instance *p_instance) {
p_instance->version++;
if (p_instance->base_type == INSTANCE_LIGHT) {
rasterizer->light_instance_set_transform( p_instance->light_info->instance, p_instance->data.transform );
}
if (p_instance->aabb.has_no_surface())
return;
if (p_instance->base_type == INSTANCE_PARTICLES) {
rasterizer->particles_instance_set_transform( p_instance->particles_info->instance, p_instance->data.transform );
}
if ((1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
//make sure lights are updated
InstanceSet::Element *E=p_instance->lights.front();
while(E) {
E->get()->version++;
E=E->next();
}
} else if (p_instance->base_type == INSTANCE_ROOM) {
p_instance->room_info->affine_inverse=p_instance->data.transform.affine_inverse();
} else if (p_instance->base_type == INSTANCE_BAKED_LIGHT) {
Transform scale;
scale.basis.scale(p_instance->baked_light_info->baked_light->octree_aabb.size);
scale.origin=p_instance->baked_light_info->baked_light->octree_aabb.pos;
//print_line("scale: "+scale);
p_instance->baked_light_info->affine_inverse=(p_instance->data.transform*scale).affine_inverse();
}
p_instance->data.mirror = p_instance->data.transform.basis.determinant() < 0.0;
AABB new_aabb;
if (p_instance->base_type==INSTANCE_PORTAL) {
//portals need to be transformed in a special way, so they don't become too wide if they have scale..
Transform portal_xform = p_instance->data.transform;
portal_xform.basis.set_axis(2,portal_xform.basis.get_axis(2).normalized());
p_instance->portal_info->plane_cache=Plane( p_instance->data.transform.origin, portal_xform.basis.get_axis(2));
int point_count=p_instance->portal_info->portal->shape.size();
p_instance->portal_info->transformed_point_cache.resize(point_count);
AABB portal_aabb;
for(int i=0;i<point_count;i++) {
Point2 src = p_instance->portal_info->portal->shape[i];
Vector3 point = portal_xform.xform(Vector3(src.x,src.y,0));
p_instance->portal_info->transformed_point_cache[i]=point;
if (i==0)
portal_aabb.pos=point;
else
portal_aabb.expand_to(point);
}
portal_aabb.grow_by(p_instance->portal_info->portal->connect_range);
new_aabb = portal_aabb;
} else {
new_aabb = p_instance->data.transform.xform(p_instance->aabb);
}
for(InstanceSet::Element *E=p_instance->lights.front();E;E=E->next()) {
Instance *light = E->get();
light->version++;
}
p_instance->transformed_aabb=new_aabb;
if (!p_instance->scenario) {
return;
}
if (p_instance->octree_id==0) {
uint32_t base_type = 1<<p_instance->base_type;
uint32_t pairable_mask=0;
bool pairable=false;
if (p_instance->base_type == INSTANCE_LIGHT) {
pairable_mask=p_instance->light_info->enabled?INSTANCE_GEOMETRY_MASK:0;
pairable=true;
}
if (p_instance->base_type == INSTANCE_PORTAL) {
pairable_mask=(1<<INSTANCE_PORTAL);
pairable=true;
}
if (p_instance->base_type == INSTANCE_BAKED_LIGHT_SAMPLER) {
pairable_mask=(1<<INSTANCE_BAKED_LIGHT);
pairable=true;
}
if (!p_instance->room && (1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
base_type|=INSTANCE_ROOMLESS_MASK;
}
if (p_instance->base_type == INSTANCE_ROOM) {
pairable_mask=INSTANCE_ROOMLESS_MASK;
pairable=true;
}
// not inside octree
p_instance->octree_id = p_instance->scenario->octree.create(p_instance,new_aabb,0,pairable,base_type,pairable_mask);
} else {
// if (new_aabb==p_instance->data.transformed_aabb)
// return;
p_instance->scenario->octree.move(p_instance->octree_id,new_aabb);
}
if (p_instance->base_type==INSTANCE_PORTAL) {
_portal_attempt_connect(p_instance);
}
if (!p_instance->room && (1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
_instance_validate_autorooms(p_instance);
}
if (p_instance->base_type == INSTANCE_ROOM) {
for(Set<Instance*>::Element *E=p_instance->room_info->owned_autoroom_geometry.front();E;E=E->next())
_instance_validate_autorooms(E->get());
}
}
void VisualServerRaster::_update_instance_aabb(Instance *p_instance) {
AABB new_aabb;
ERR_FAIL_COND(p_instance->base_type!=INSTANCE_NONE && !p_instance->base_rid.is_valid());
switch(p_instance->base_type) {
case VisualServer::INSTANCE_NONE: {
// do nothing
} break;
case VisualServer::INSTANCE_MESH: {
new_aabb = rasterizer->mesh_get_aabb(p_instance->base_rid,p_instance->data.skeleton);
} break;
case VisualServer::INSTANCE_MULTIMESH: {
new_aabb = rasterizer->multimesh_get_aabb(p_instance->base_rid);
} break;
case VisualServer::INSTANCE_IMMEDIATE: {
new_aabb = rasterizer->immediate_get_aabb(p_instance->base_rid);
} break;
case VisualServer::INSTANCE_PARTICLES: {
new_aabb = rasterizer->particles_get_aabb(p_instance->base_rid);
} break;
case VisualServer::INSTANCE_LIGHT: {
new_aabb = rasterizer->light_get_aabb(p_instance->base_rid);
} break;
case VisualServer::INSTANCE_ROOM: {
Room *room = room_owner.get( p_instance->base_rid );
ERR_FAIL_COND(!room);
new_aabb=room->bounds.get_aabb();
} break;
case VisualServer::INSTANCE_PORTAL: {
Portal *portal = portal_owner.get( p_instance->base_rid );
ERR_FAIL_COND(!portal);
for (int i=0;i<portal->shape.size();i++) {
Vector3 point( portal->shape[i].x, portal->shape[i].y, 0 );
if (i==0) {
new_aabb.pos=point;
new_aabb.size.z=0.01; // make it not flat for octree
} else {
new_aabb.expand_to(point);
}
}
} break;
case VisualServer::INSTANCE_BAKED_LIGHT: {
BakedLight *baked_light = baked_light_owner.get( p_instance->base_rid );
ERR_FAIL_COND(!baked_light);
new_aabb=baked_light->octree_aabb;
} break;
case VisualServer::INSTANCE_BAKED_LIGHT_SAMPLER: {
BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get( p_instance->base_rid );
ERR_FAIL_COND(!baked_light_sampler);
float radius = baked_light_sampler->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
new_aabb=AABB(Vector3(-radius,-radius,-radius),Vector3(radius*2,radius*2,radius*2));
} break;
default: {}
}
if (p_instance->extra_margin)
new_aabb.grow_by(p_instance->extra_margin);
p_instance->aabb=new_aabb;
}
void VisualServerRaster::_update_instances() {
while(instance_update_list) {
Instance *instance=instance_update_list;
instance_update_list=instance_update_list->update_next;
if (instance->update_aabb)
_update_instance_aabb(instance);
if (instance->update_materials) {
if (instance->base_type==INSTANCE_MESH) {
instance->data.materials.resize(rasterizer->mesh_get_surface_count(instance->base_rid));
}
}
_update_instance(instance);
instance->update=false;
instance->update_aabb=false;
instance->update_materials=false;
instance->update_next=0;
}
}
void VisualServerRaster::instance_light_set_enabled(RID p_instance,bool p_enabled) {
VS_CHANGED;
Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND( !instance );
ERR_FAIL_COND( instance->base_type!=INSTANCE_LIGHT );
if (p_enabled==instance->light_info->enabled)
return;
instance->light_info->enabled=p_enabled;
if (light_get_type(instance->base_rid)!=VS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario)
instance->scenario->octree.set_pairable(instance->octree_id,p_enabled,1<<INSTANCE_LIGHT,p_enabled?INSTANCE_GEOMETRY_MASK:0);
//_instance_queue_update( instance , true );
}
bool VisualServerRaster::instance_light_is_enabled(RID p_instance) const {
const Instance *instance = instance_owner.get( p_instance );
ERR_FAIL_COND_V( !instance,false );
ERR_FAIL_COND_V( instance->base_type!=INSTANCE_LIGHT,false );
return instance->light_info->enabled;
}
/****** CANVAS *********/
RID VisualServerRaster::canvas_create() {
Canvas * canvas = memnew( Canvas );
ERR_FAIL_COND_V(!canvas,RID());
RID rid = canvas_owner.make_rid( canvas );
return rid;
}
void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas,RID p_item,const Point2& p_mirroring) {
Canvas * canvas = canvas_owner.get(p_canvas);
ERR_FAIL_COND(!canvas);
CanvasItem *canvas_item = canvas_item_owner.get(p_item);
ERR_FAIL_COND(!canvas_item);
int idx = canvas->find_item(canvas_item);
ERR_FAIL_COND(idx==-1);
canvas->child_items[idx].mirror=p_mirroring;
}
Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas,RID p_item) const {
Canvas * canvas = canvas_owner.get(p_canvas);
ERR_FAIL_COND_V(!canvas,Point2());
CanvasItem *canvas_item = memnew( CanvasItem );
ERR_FAIL_COND_V(!canvas_item,Point2());
int idx = canvas->find_item(canvas_item);
ERR_FAIL_COND_V(idx==-1,Point2());
return canvas->child_items[idx].mirror;
}
void VisualServerRaster::canvas_set_modulate(RID p_canvas,const Color& p_color) {
Canvas * canvas = canvas_owner.get(p_canvas);
ERR_FAIL_COND(!canvas);
canvas->modulate=p_color;
}
RID VisualServerRaster::canvas_item_create() {
CanvasItem *canvas_item = memnew( CanvasItem );
ERR_FAIL_COND_V(!canvas_item,RID());
return canvas_item_owner.make_rid( canvas_item );
}
void VisualServerRaster::canvas_item_set_parent(RID p_item,RID p_parent) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
if (canvas_item->parent.is_valid()) {
if (canvas_owner.owns(canvas_item->parent)) {
Canvas *canvas = canvas_owner.get(canvas_item->parent);
canvas->erase_item(canvas_item);
} else if (canvas_item_owner.owns(canvas_item->parent)) {
CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
item_owner->child_items.erase(canvas_item);
}
canvas_item->parent=RID();
}
if (p_parent.is_valid()) {
if (canvas_owner.owns(p_parent)) {
Canvas *canvas = canvas_owner.get(p_parent);
Canvas::ChildItem ci;
ci.item=canvas_item;
canvas->child_items.push_back(ci);
} else if (canvas_item_owner.owns(p_parent)) {
CanvasItem *item_owner = canvas_item_owner.get(p_parent);
item_owner->child_items.push_back(canvas_item);
} else {
ERR_EXPLAIN("Invalid parent");
ERR_FAIL();
}
}
canvas_item->parent=p_parent;
}
RID VisualServerRaster::canvas_item_get_parent(RID p_canvas_item) const {
CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
ERR_FAIL_COND_V(!canvas_item,RID());
return canvas_item->parent;
}
void VisualServerRaster::canvas_item_set_visible(RID p_item,bool p_visible) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->visible=p_visible;
}
bool VisualServerRaster::canvas_item_is_visible(RID p_item) const {
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND_V(!canvas_item,RID());
return canvas_item->visible;
}
void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item,int p_mask) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
ERR_FAIL_COND(!canvas_item);
if (canvas_item->light_mask==p_mask)
return;
VS_CHANGED;
canvas_item->light_mask=p_mask;
}
void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item,MaterialBlendMode p_blend) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
ERR_FAIL_COND(!canvas_item);
if (canvas_item->blend_mode==p_blend)
return;
VS_CHANGED;
canvas_item->blend_mode=p_blend;
}
void VisualServerRaster::canvas_item_attach_viewport(RID p_canvas_item, RID p_viewport) {
CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
ERR_FAIL_COND(!canvas_item);
VS_CHANGED;
canvas_item->viewport=p_viewport;
}
/*
void VisualServerRaster::canvas_item_set_rect(RID p_item, const Rect2& p_rect) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->rect=p_rect;
}*/
void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->clip=p_clip;
}
void VisualServerRaster::canvas_item_set_distance_field_mode(RID p_item, bool p_distance_field) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->distance_field=p_distance_field;
}
void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32& p_transform) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->xform=p_transform;
}
void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect,const Rect2& p_rect) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->custom_rect=p_custom_rect;
if (p_custom_rect)
canvas_item->rect=p_rect;
}
void VisualServerRaster::canvas_item_set_opacity(RID p_item, float p_opacity) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->opacity=p_opacity;
}
float VisualServerRaster::canvas_item_get_opacity(RID p_item, float p_opacity) const {
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND_V(!canvas_item,-1);
return canvas_item->opacity;
}
void VisualServerRaster::canvas_item_set_on_top(RID p_item, bool p_on_top) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->ontop=p_on_top;
}
bool VisualServerRaster::canvas_item_is_on_top(RID p_item) const{
const CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND_V(!canvas_item,false);
return canvas_item->ontop;
}
void VisualServerRaster::canvas_item_set_self_opacity(RID p_item, float p_self_opacity) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->self_opacity=p_self_opacity;
}
float VisualServerRaster::canvas_item_get_self_opacity(RID p_item, float p_self_opacity) const {
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND_V(!canvas_item,-1);
return canvas_item->self_opacity;
}
void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2& p_from, const Point2& p_to,const Color& p_color,float p_width) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandLine * line = memnew( CanvasItem::CommandLine );
ERR_FAIL_COND(!line);
line->color=p_color;
line->from=p_from;
line->to=p_to;
line->width=p_width;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(line);
}
void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2& p_rect, const Color& p_color) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
ERR_FAIL_COND(!rect);
rect->modulate=p_color;
rect->rect=p_rect;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(rect);
}
void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2& p_pos, float p_radius,const Color& p_color) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandCircle * circle = memnew( CanvasItem::CommandCircle );
ERR_FAIL_COND(!circle);
circle->color=p_color;
circle->pos=p_pos;
circle->radius=p_radius;
canvas_item->commands.push_back(circle);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
ERR_FAIL_COND(!rect);
rect->modulate=p_modulate;
rect->rect=p_rect;
rect->flags=0;
if (p_tile) {
rect->flags|=Rasterizer::CANVAS_RECT_TILE;
rect->flags|=Rasterizer::CANVAS_RECT_REGION;
rect->source=Rect2(0,0,p_rect.size.width,p_rect.size.height);
}
if (p_rect.size.x<0) {
rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
rect->rect.size.x = -rect->rect.size.x;
}
if (p_rect.size.y<0) {
rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
rect->rect.size.y = -rect->rect.size.y;
}
if (p_transpose) {
rect->flags|=Rasterizer::CANVAS_RECT_TRANSPOSE;
SWAP(rect->rect.size.x, rect->rect.size.y);
}
rect->texture=p_texture;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(rect);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
ERR_FAIL_COND(!rect);
rect->modulate=p_modulate;
rect->rect=p_rect;
rect->texture=p_texture;
rect->source=p_src_rect;
rect->flags=Rasterizer::CANVAS_RECT_REGION;
if (p_rect.size.x<0) {
rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
rect->rect.size.x = -rect->rect.size.x;
}
if (p_rect.size.y<0) {
rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
rect->rect.size.y = -rect->rect.size.y;
}
if (p_transpose) {
rect->flags|=Rasterizer::CANVAS_RECT_TRANSPOSE;
SWAP(rect->rect.size.x, rect->rect.size.y);
}
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(rect);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandStyle * style = memnew( CanvasItem::CommandStyle );
ERR_FAIL_COND(!style);
style->texture=p_texture;
style->rect=p_rect;
style->source=p_source;
style->draw_center=p_draw_center;
style->color=p_modulate;
style->margin[MARGIN_LEFT]=p_topleft.x;
style->margin[MARGIN_TOP]=p_topleft.y;
style->margin[MARGIN_RIGHT]=p_bottomright.x;
style->margin[MARGIN_BOTTOM]=p_bottomright.y;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(style);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandPrimitive * prim = memnew( CanvasItem::CommandPrimitive );
ERR_FAIL_COND(!prim);
prim->texture=p_texture;
prim->points=p_points;
prim->uvs=p_uvs;
prim->colors=p_colors;
prim->width=p_width;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(prim);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
#ifdef DEBUG_ENABLED
int pointcount = p_points.size();
ERR_FAIL_COND(pointcount<3);
int color_size=p_colors.size();
int uv_size=p_uvs.size();
ERR_FAIL_COND(color_size!=0 && color_size!=1 && color_size!=pointcount);
ERR_FAIL_COND(uv_size!=0 && (uv_size!=pointcount || !p_texture.is_valid()));
#endif
Vector<int> indices = Geometry::triangulate_polygon(p_points);
if (indices.empty()) {
ERR_EXPLAIN("Bad Polygon!");
ERR_FAIL_V();
}
CanvasItem::CommandPolygon * polygon = memnew( CanvasItem::CommandPolygon );
ERR_FAIL_COND(!polygon);
polygon->texture=p_texture;
polygon->points=p_points;
polygon->uvs=p_uvs;
polygon->colors=p_colors;
polygon->indices=indices;
polygon->count=indices.size();
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(polygon);
}
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
ERR_FAIL_COND(p_count <= 0);
ERR_FAIL_COND(p_points == NULL);
CanvasItem::CommandPolygonPtr * polygon = memnew( CanvasItem::CommandPolygonPtr );
ERR_FAIL_COND(!polygon);
polygon->texture=p_texture;
polygon->points=p_points;
polygon->uvs=p_uvs;
polygon->colors=p_colors;
polygon->indices=p_indices;
polygon->count = p_count * 3;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(polygon);
};
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) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
int ps = p_points.size();
ERR_FAIL_COND(!p_colors.empty() && p_colors.size()!=ps && p_colors.size()!=1);
ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size()!=ps);
Vector<int> indices = p_indices;
int count = p_count * 3;
if (indices.empty()) {
ERR_FAIL_COND( ps % 3 != 0 );
if (p_count == -1)
count = ps;
} else {
ERR_FAIL_COND( indices.size() % 3 != 0 );
if (p_count == -1)
count = indices.size();
}
CanvasItem::CommandPolygon * polygon = memnew( CanvasItem::CommandPolygon );
ERR_FAIL_COND(!polygon);
polygon->texture=p_texture;
polygon->points=p_points;
polygon->uvs=p_uvs;
polygon->colors=p_colors;
polygon->indices=indices;
polygon->count = count;
canvas_item->rect_dirty=true;
canvas_item->commands.push_back(polygon);
}
void VisualServerRaster::canvas_item_add_set_transform(RID p_item,const Matrix32& p_transform) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandTransform * tr = memnew( CanvasItem::CommandTransform );
ERR_FAIL_COND(!tr);
tr->xform=p_transform;
canvas_item->commands.push_back(tr);
}
void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandBlendMode * bm = memnew( CanvasItem::CommandBlendMode );
ERR_FAIL_COND(!bm);
bm->blend_mode = p_blend;
canvas_item->commands.push_back(bm);
};
void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z) {
ERR_FAIL_COND(p_z<CANVAS_ITEM_Z_MIN || p_z>CANVAS_ITEM_Z_MAX);
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->z=p_z;
}
void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->z_relative=p_enable;
}
void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2& p_rect) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
if (bool(canvas_item->copy_back_buffer!=NULL) !=p_enable) {
if (p_enable) {
canvas_item->copy_back_buffer = memnew( Rasterizer::CanvasItem::CopyBackBuffer );
} else {
memdelete(canvas_item->copy_back_buffer);
canvas_item->copy_back_buffer=NULL;
}
}
if (p_enable) {
canvas_item->copy_back_buffer->rect=p_rect;
canvas_item->copy_back_buffer->full=p_rect==Rect2();
}
}
void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->use_parent_material=p_enable;
}
void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
if (canvas_item->material)
canvas_item->material->owners.erase(canvas_item);
canvas_item->material=NULL;
if (canvas_item_material_owner.owns(p_material)) {
canvas_item->material=canvas_item_material_owner.get(p_material);
canvas_item->material->owners.insert(canvas_item);
}
}
void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->sort_y=p_enable;
}
void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
CanvasItem::CommandClipIgnore * ci = memnew( CanvasItem::CommandClipIgnore);
ERR_FAIL_COND(!ci);
ci->ignore=p_ignore;
canvas_item->commands.push_back(ci);
}
void VisualServerRaster::canvas_item_clear(RID p_item) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
canvas_item->clear();
}
void VisualServerRaster::canvas_item_raise(RID p_item) {
VS_CHANGED;
CanvasItem *canvas_item = canvas_item_owner.get( p_item );
ERR_FAIL_COND(!canvas_item);
if (canvas_item->parent.is_valid()) {
if (canvas_owner.owns(canvas_item->parent)) {
Canvas *canvas = canvas_owner.get(canvas_item->parent);
int idx = canvas->find_item(canvas_item);
ERR_FAIL_COND(idx<0);
Canvas::ChildItem ci = canvas->child_items[idx];
canvas->child_items.remove(idx);
canvas->child_items.push_back(ci);
} else if (canvas_item_owner.owns(canvas_item->parent)) {
CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
int idx = item_owner->child_items.find(canvas_item);
ERR_FAIL_COND(idx<0);
item_owner->child_items.remove(idx);
item_owner->child_items.push_back(canvas_item);
}
}
}
/***** CANVAS LIGHT *******/
RID VisualServerRaster::canvas_light_create() {
Rasterizer::CanvasLight *clight = memnew( Rasterizer::CanvasLight );
return canvas_light_owner.make_rid(clight);
}
void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light,RID p_canvas){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
if (clight->canvas.is_valid()) {
Canvas *canvas = canvas_owner.get(clight->canvas);
canvas->lights.erase(clight);
}
if (!canvas_owner.owns(p_canvas))
p_canvas=RID();
clight->canvas=p_canvas;
if (clight->canvas.is_valid()) {
Canvas *canvas = canvas_owner.get(clight->canvas);
canvas->lights.insert(clight);
}
}
void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->enabled=p_enabled;
}
void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32& p_transform){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->xform=p_transform;
}
void VisualServerRaster::canvas_light_set_scale(RID p_light, float p_scale) {
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->scale=p_scale;
}
void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->texture=p_texture;
}
void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->texture_offset=p_offset;
}
void VisualServerRaster::canvas_light_set_color(RID p_light, const Color& p_color){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->color=p_color;
}
void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->height=p_height;
}
void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->energy=p_energy;
}
void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->z_min=p_min_z;
clight->z_max=p_max_z;
}
void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer,int p_max_layer) {
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->layer_min=p_min_layer;
clight->layer_max=p_max_layer;
}
void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->item_mask=p_mask;
}
void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->item_shadow_mask=p_mask;
}
void VisualServerRaster::canvas_light_set_mode(RID p_light, CanvasLightMode p_mode) {
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->mode=p_mode;
}
void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
if (clight->shadow_buffer.is_valid()==p_enabled)
return;
if (p_enabled) {
clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
} else {
rasterizer->free(clight->shadow_buffer);
clight->shadow_buffer=RID();
}
}
void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size){
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
ERR_FAIL_COND(p_size<32 || p_size>16384);
clight->shadow_buffer_size=nearest_power_of_2(p_size);
if (clight->shadow_buffer.is_valid()) {
rasterizer->free(clight->shadow_buffer);
clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
}
}
void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier) {
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->shadow_esm_mult=p_multiplier;
}
void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color& p_color) {
Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
clight->shadow_color=p_color;
}
/****** CANVAS LIGHT OCCLUDER ******/
RID VisualServerRaster::canvas_light_occluder_create() {
Rasterizer::CanvasLightOccluderInstance *occluder = memnew( Rasterizer::CanvasLightOccluderInstance );
return canvas_light_occluder_owner.make_rid( occluder );
}
void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas) {
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
if (occluder->canvas.is_valid()) {
Canvas *canvas = canvas_owner.get(occluder->canvas);
canvas->occluders.erase(occluder);
}
if (!canvas_owner.owns(p_canvas))
p_canvas=RID();
occluder->canvas=p_canvas;
if (occluder->canvas.is_valid()) {
Canvas *canvas = canvas_owner.get(occluder->canvas);
canvas->occluders.insert(occluder);
}
}
void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled){
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
occluder->enabled=p_enabled;
}
void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon) {
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
if (occluder->polygon.is_valid()) {
CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
if (occluder_poly) {
occluder_poly->owners.erase(occluder);
}
}
occluder->polygon=p_polygon;
occluder->polygon_buffer=RID();
if (occluder->polygon.is_valid()) {
CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
if (!occluder_poly)
occluder->polygon=RID();
ERR_FAIL_COND(!occluder_poly);
occluder_poly->owners.insert(occluder);
occluder->polygon_buffer=occluder_poly->occluder;
occluder->aabb_cache=occluder_poly->aabb;
occluder->cull_cache=occluder_poly->cull_mode;
}
}
void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform) {
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
occluder->xform=p_xform;
}
void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask) {
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
occluder->light_mask=p_mask;
}
RID VisualServerRaster::canvas_occluder_polygon_create() {
CanvasLightOccluderPolygon * occluder_poly = memnew( CanvasLightOccluderPolygon );
occluder_poly->occluder=rasterizer->canvas_light_occluder_create();
return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
}
void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2>& p_shape, bool p_close){
if (p_shape.size()<3) {
canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,p_shape);
return;
}
DVector<Vector2> lines;
int lc = p_shape.size()*2;
lines.resize(lc-(p_close?0:2));
{
DVector<Vector2>::Write w = lines.write();
DVector<Vector2>::Read r = p_shape.read();
int max=lc/2;
if (!p_close) {
max--;
}
for(int i=0;i<max;i++) {
Vector2 a = r[i];
Vector2 b = r[(i+1)%(lc/2)];
w[i*2+0]=a;
w[i*2+1]=b;
}
}
canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,lines);
}
void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape) {
CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
ERR_FAIL_COND(!occluder_poly);
ERR_FAIL_COND(p_shape.size()&1);
int lc = p_shape.size();
occluder_poly->aabb=Rect2();
{
DVector<Vector2>::Read r = p_shape.read();
for(int i=0;i<lc;i++) {
if (i==0)
occluder_poly->aabb.pos=r[i];
else
occluder_poly->aabb.expand_to(r[i]);
}
}
rasterizer->canvas_light_occluder_set_polylines(occluder_poly->occluder,p_shape);
for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
E->get()->aabb_cache=occluder_poly->aabb;
}
}
void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode) {
CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
ERR_FAIL_COND(!occluder_poly);
occluder_poly->cull_mode=p_mode;
for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
E->get()->cull_cache=p_mode;
}
}
RID VisualServerRaster::canvas_item_material_create() {
Rasterizer::CanvasItemMaterial *material = memnew( Rasterizer::CanvasItemMaterial );
return canvas_item_material_owner.make_rid(material);
}
void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader){
VS_CHANGED;
Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
material->shader=p_shader;
}
void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value){
VS_CHANGED;
Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
if (p_value.get_type()==Variant::NIL)
material->shader_param.erase(p_param);
else
material->shader_param[p_param]=p_value;
}
Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const{
Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND_V(!material,Variant());
if (!material->shader_param.has(p_param)) {
ERR_FAIL_COND_V(!material->shader.is_valid(),Variant());
return rasterizer->shader_get_default_param(material->shader,p_param);
}
return material->shader_param[p_param];
}
void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode) {
VS_CHANGED;
Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
ERR_FAIL_COND(!material);
material->shading_mode=p_mode;
}
/******** CANVAS *********/
void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor) {
VS_CHANGED;
ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
cursors[p_cursor].rot = p_rotation;
};
void VisualServerRaster::cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor, const Rect2 &p_region) {
VS_CHANGED;
ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
cursors[p_cursor].texture = p_texture;
cursors[p_cursor].center = p_center_offset;
cursors[p_cursor].region = p_region;
};
void VisualServerRaster::cursor_set_visible(bool p_visible, int p_cursor) {
VS_CHANGED;
ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
cursors[p_cursor].visible = p_visible;
};
void VisualServerRaster::cursor_set_pos(const Point2& p_pos, int p_cursor) {
ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
if (cursors[p_cursor].pos==p_pos)
return;
VS_CHANGED;
cursors[p_cursor].pos = p_pos;
};
void VisualServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
black_margin[MARGIN_LEFT]=p_left;
black_margin[MARGIN_TOP]=p_top;
black_margin[MARGIN_RIGHT]=p_right;
black_margin[MARGIN_BOTTOM]=p_bottom;
}
void VisualServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
black_image[MARGIN_LEFT]=p_left;
black_image[MARGIN_TOP]=p_top;
black_image[MARGIN_RIGHT]=p_right;
black_image[MARGIN_BOTTOM]=p_bottom;
}
void VisualServerRaster::_free_attached_instances(RID p_rid,bool p_free_scenario) {
Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
if (E) {
// has instances
while( E->get().size() ) {
// erase all attached instances
if (p_free_scenario)
instance_set_scenario( E->get().front()->get(), RID() );
else
instance_set_base( E->get().front()->get(), RID() );
}
}
instance_dependency_map.erase(p_rid);
}
void VisualServerRaster::custom_shade_model_set_shader(int p_model, RID p_shader) {
VS_CHANGED;
// rasterizer->custom_shade_model_set_shader(p_model,p_shader);
}
RID VisualServerRaster::custom_shade_model_get_shader(int p_model) const {
//return rasterizer->custom_shade_model_get_shader(p_model);
return RID();
}
void VisualServerRaster::custom_shade_model_set_name(int p_model, const String& p_name) {
//rasterizer->custom_shade_model_set_name(p_model,p_name);
}
String VisualServerRaster::custom_shade_model_get_name(int p_model) const {
//return rasterizer->custom_shade_model_get_name(p_model);
return "";
}
void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo>& p_info) {
VS_CHANGED;
//rasterizer->custom_shade_model_set_param_info(p_model,p_info);
}
void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo>* p_info) const {
//rasterizer->custom_shade_model_get_param_info(p_model,p_info);
}
void VisualServerRaster::free( RID p_rid ) {
VS_CHANGED;
if (rasterizer->is_texture(p_rid) || rasterizer->is_material(p_rid) || rasterizer->is_shader(p_rid) || rasterizer->is_environment(p_rid)) {
rasterizer->free(p_rid);
} else if (rasterizer->is_skeleton(p_rid)) {
Map< RID, Set<Instance*> >::Element *E=skeleton_dependency_map.find(p_rid);
if (E) {
//detach skeletons
for (Set<Instance*>::Element *F=E->get().front();F;F=F->next()) {
F->get()->data.skeleton=RID();
}
skeleton_dependency_map.erase(E);
}
rasterizer->free(p_rid);
} 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)) {
//delete the resource
_free_attached_instances(p_rid);
rasterizer->free(p_rid);
} else if (room_owner.owns(p_rid)) {
_free_attached_instances(p_rid);
Room *room = room_owner.get(p_rid);
ERR_FAIL_COND(!room);
room_owner.free(p_rid);
memdelete(room);
} else if (portal_owner.owns(p_rid)) {
_free_attached_instances(p_rid);
Portal *portal = portal_owner.get(p_rid);
ERR_FAIL_COND(!portal);
portal_owner.free(p_rid);
memdelete(portal);
} else if (baked_light_owner.owns(p_rid)) {
_free_attached_instances(p_rid);
BakedLight *baked_light = baked_light_owner.get(p_rid);
ERR_FAIL_COND(!baked_light);
if (baked_light->data.octree_texture.is_valid())
rasterizer->free(baked_light->data.octree_texture);
baked_light_owner.free(p_rid);
memdelete(baked_light);
} else if (baked_light_sampler_owner.owns(p_rid)) {
_free_attached_instances(p_rid);
BakedLightSampler *baked_light_sampler = baked_light_sampler_owner.get(p_rid);
ERR_FAIL_COND(!baked_light_sampler);
//if (baked_light->data.octree_texture.is_valid())
// rasterizer->free(baked_light->data.octree_texture);
baked_light_sampler_owner.free(p_rid);
memdelete(baked_light_sampler);
} else if (camera_owner.owns(p_rid)) {
// delete te camera
Camera *camera = camera_owner.get(p_rid);
ERR_FAIL_COND(!camera);
camera_owner.free( p_rid );
memdelete(camera);
} else if (viewport_owner.owns(p_rid)) {
// delete the viewport
Viewport *viewport = viewport_owner.get( p_rid );
ERR_FAIL_COND(!viewport);
// Viewport *parent=NULL;
rasterizer->free(viewport->viewport_data);
if (viewport->render_target.is_valid()) {
rasterizer->free(viewport->render_target);
}
if (viewport->update_list.in_list())
viewport_update_list.remove(&viewport->update_list);
if (screen_viewports.has(p_rid))
screen_viewports.erase(p_rid);
while(viewport->canvas_map.size()) {
Canvas *c = viewport->canvas_map.front()->get().canvas;
c->viewports.erase(p_rid);
viewport->canvas_map.erase(viewport->canvas_map.front());
}
viewport_owner.free(p_rid);
memdelete(viewport);
} else if (instance_owner.owns(p_rid)) {
// delete the instance
_update_instances(); // be sure
Instance *instance = instance_owner.get(p_rid);
ERR_FAIL_COND(!instance);
instance_set_room(p_rid,RID());
instance_set_scenario(p_rid,RID());
instance_geometry_set_baked_light(p_rid,RID());
instance_geometry_set_baked_light_sampler(p_rid,RID());
instance_set_base(p_rid,RID());
if (instance->data.skeleton.is_valid())
instance_attach_skeleton(p_rid,RID());
instance_owner.free(p_rid);
memdelete(instance);
} else if (canvas_owner.owns(p_rid)) {
Canvas *canvas = canvas_owner.get(p_rid);
ERR_FAIL_COND(!canvas);
while(canvas->viewports.size()) {
Viewport *vp = viewport_owner.get(canvas->viewports.front()->get());
ERR_FAIL_COND(!vp);
Map<RID,Viewport::CanvasData>::Element *E=vp->canvas_map.find(p_rid);
ERR_FAIL_COND(!E);
vp->canvas_map.erase(p_rid);
canvas->viewports.erase( canvas->viewports.front() );
}
for (int i=0;i<canvas->child_items.size();i++) {
canvas->child_items[i].item->parent=RID();
}
for (Set<Rasterizer::CanvasLight*>::Element *E=canvas->lights.front();E;E=E->next()) {
E->get()->canvas=RID();
}
for (Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=canvas->occluders.front();E;E=E->next()) {
E->get()->canvas=RID();
}
canvas_owner.free( p_rid );
memdelete( canvas );
} else if (canvas_item_owner.owns(p_rid)) {
CanvasItem *canvas_item = canvas_item_owner.get(p_rid);
ERR_FAIL_COND(!canvas_item);
if (canvas_item->parent.is_valid()) {
if (canvas_owner.owns(canvas_item->parent)) {
Canvas *canvas = canvas_owner.get(canvas_item->parent);
canvas->erase_item(canvas_item);
} else if (canvas_item_owner.owns(canvas_item->parent)) {
CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
item_owner->child_items.erase(canvas_item);
}
}
for (int i=0;i<canvas_item->child_items.size();i++) {
canvas_item->child_items[i]->parent=RID();
}
if (canvas_item->material) {
canvas_item->material->owners.erase(canvas_item);
}
canvas_item_owner.free( p_rid );
memdelete( canvas_item );
} else if (canvas_item_material_owner.owns(p_rid)) {
Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_rid);
ERR_FAIL_COND(!material);
for(Set<Rasterizer::CanvasItem*>::Element *E=material->owners.front();E;E=E->next()) {
E->get()->material=NULL;
}
canvas_item_material_owner.free(p_rid);
memdelete(material);
} else if (canvas_light_owner.owns(p_rid)) {
Rasterizer::CanvasLight *canvas_light = canvas_light_owner.get(p_rid);
ERR_FAIL_COND(!canvas_light);
if (canvas_light->canvas.is_valid()) {
Canvas* canvas = canvas_owner.get(canvas_light->canvas);
if (canvas)
canvas->lights.erase(canvas_light);
}
if (canvas_light->shadow_buffer.is_valid())
rasterizer->free(canvas_light->shadow_buffer);
canvas_light_owner.free( p_rid );
memdelete( canvas_light );
} else if (canvas_light_occluder_owner.owns(p_rid)) {
Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_rid);
ERR_FAIL_COND(!occluder);
if (occluder->polygon.is_valid()) {
CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(occluder->polygon);
if (occluder_poly) {
occluder_poly->owners.erase(occluder);
}
}
if (occluder->canvas.is_valid() && canvas_owner.owns(occluder->canvas)) {
Canvas *canvas = canvas_owner.get(occluder->canvas);
canvas->occluders.erase(occluder);
}
canvas_light_occluder_owner.free( p_rid );
memdelete(occluder);
} else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_rid);
ERR_FAIL_COND(!occluder_poly);
rasterizer->free(occluder_poly->occluder);
while(occluder_poly->owners.size()) {
occluder_poly->owners.front()->get()->polygon=RID();
occluder_poly->owners.erase( occluder_poly->owners.front() );
}
canvas_light_occluder_polygon_owner.free( p_rid );
memdelete(occluder_poly);
} else if (scenario_owner.owns(p_rid)) {
Scenario *scenario=scenario_owner.get(p_rid);
ERR_FAIL_COND(!scenario);
_update_instances(); // be sure
_free_attached_instances(p_rid,true);
//rasterizer->free( scenario->environment );
scenario_owner.free(p_rid);
memdelete(scenario);
} else {
ERR_FAIL();
}
}
void VisualServerRaster::_instance_draw(Instance *p_instance) {
if (p_instance->light_cache_dirty) {
int l=0;
//add positional lights
InstanceSet::Element *LE=p_instance->lights.front();
p_instance->data.light_instances.resize(p_instance->lights.size());
while(LE) {
p_instance->data.light_instances[l++]=LE->get()->light_info->instance;
LE=LE->next();
}
p_instance->light_cache_dirty=false;
}
switch(p_instance->base_type) {
case INSTANCE_MESH: {
rasterizer->add_mesh(p_instance->base_rid, &p_instance->data);
} break;
case INSTANCE_MULTIMESH: {
rasterizer->add_multimesh(p_instance->base_rid, &p_instance->data);
} break;
case INSTANCE_IMMEDIATE: {
rasterizer->add_immediate(p_instance->base_rid, &p_instance->data);
} break;
case INSTANCE_PARTICLES: {
rasterizer->add_particles(p_instance->particles_info->instance, &p_instance->data);
} break;
default: {};
}
}
Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max) {
// setup a camera matrix for that range!
CameraMatrix camera_matrix;
switch(p_camera->type) {
case Camera::ORTHOGONAL: {
camera_matrix.set_orthogonal(p_camera->size,viewport_rect.width / (float)viewport_rect.height,p_range_min,p_range_max,p_camera->vaspect);
} break;
case Camera::PERSPECTIVE: {
camera_matrix.set_perspective(
p_camera->fov,
viewport_rect.width / (float)viewport_rect.height,
p_range_min,
p_range_max,
p_camera->vaspect
);
} break;
}
//obtain the frustum endpoints
Vector<Vector3> endpoints;
endpoints.resize(8);
bool res = camera_matrix.get_endpoints(p_camera->transform,&endpoints[0]);
ERR_FAIL_COND_V(!res,Vector<Vector3>());
return endpoints;
}
Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light,Camera *p_camera,float p_range_min, float p_range_max) {
Vector<Vector3> endpoints=_camera_generate_endpoints(p_light,p_camera,p_range_min,p_range_max); // frustum plane endpoints
ERR_FAIL_COND_V(endpoints.empty(),Vector<Plane>());
// obtain the light frustm ranges (given endpoints)
Vector3 x_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_X ).normalized();
Vector3 y_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
Vector3 z_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
float x_min,x_max;
float y_min,y_max;
float z_min,z_max;
for(int j=0;j<8;j++) {
float d_x=x_vec.dot(endpoints[j]);
float d_y=y_vec.dot(endpoints[j]);
float d_z=z_vec.dot(endpoints[j]);
if (j==0 || d_x<x_min)
x_min=d_x;
if (j==0 || d_x>x_max)
x_max=d_x;
if (j==0 || d_y<y_min)
y_min=d_y;
if (j==0 || d_y>y_max)
y_max=d_y;
if (j==0 || d_z<z_min)
z_min=d_z;
if (j==0 || d_z>z_max)
z_max=d_z;
}
//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
Vector<Plane> light_frustum_planes;
light_frustum_planes.resize(6);
//right/left
light_frustum_planes[0]=Plane( x_vec, x_max );
light_frustum_planes[1]=Plane( -x_vec, -x_min );
//top/bottom
light_frustum_planes[2]=Plane( y_vec, y_max );
light_frustum_planes[3]=Plane( -y_vec, -y_min );
//near/far
light_frustum_planes[4]=Plane( z_vec, z_max+1e6 );
light_frustum_planes[5]=Plane( -z_vec, -z_min ); // z_min is ok, since casters further than far-light plane are not needed
//TODO@ add more actual frustum planes to minimize get
return light_frustum_planes;
}
void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
int splits = rasterizer->light_instance_get_shadow_passes( p_light->light_info->instance );
float split_weight=rasterizer->light_directional_get_shadow_param(p_light->base_rid,LIGHT_DIRECTIONAL_SHADOW_PARAM_PSSM_SPLIT_WEIGHT);
float distances[5];
float texsize=rasterizer->light_instance_get_shadow_size( p_light->light_info->instance );
// float cull_min=p_cull_range.min;
//float cull_max=p_cull_range.max;
bool overlap = rasterizer->light_instance_get_pssm_shadow_overlap(p_light->light_info->instance);
float cull_min=p_camera->znear;
float cull_max=p_camera->zfar;
float max_dist = rasterizer->light_directional_get_shadow_param(p_light->base_rid,VS::LIGHT_DIRECTIONAL_SHADOW_PARAM_MAX_DISTANCE);
if (max_dist>0.0)
cull_max=MIN(cull_max,max_dist);
for(int i = 0; i < splits; i++) {
float idm = i / (float)splits;
float lg = cull_min * Math::pow(cull_max/cull_min, idm);
float uniform = cull_min + (cull_max - cull_min) * idm;
distances[i] = lg * split_weight + uniform * (1.0 - split_weight);
}
distances[0]=cull_min;
distances[splits]=cull_max;
for (int i=0;i<splits;i++) {
// setup a camera matrix for that range!
CameraMatrix camera_matrix;
switch(p_camera->type) {
case Camera::ORTHOGONAL: {
camera_matrix.set_orthogonal(
p_camera->size,
viewport_rect.width / (float)viewport_rect.height,
distances[(i==0 || !overlap )?i:i-1],
distances[i+1],
p_camera->vaspect
);
} break;
case Camera::PERSPECTIVE: {
camera_matrix.set_perspective(
p_camera->fov,
viewport_rect.width / (float)viewport_rect.height,
distances[(i==0 || !overlap )?i:i-1],
distances[i+1],
p_camera->vaspect
);
} break;
}
//obtain the frustum endpoints
Vector3 endpoints[8]; // frustum plane endpoints
bool res = camera_matrix.get_endpoints(p_camera->transform,endpoints);
ERR_CONTINUE(!res);
// obtain the light frustm ranges (given endpoints)
Vector3 x_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_X ).normalized();
Vector3 y_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
Vector3 z_vec=p_light->data.transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
//z_vec points agsint the camera, like in default opengl
float x_min,x_max;
float y_min,y_max;
float z_min,z_max;
float x_min_cam,x_max_cam;
float y_min_cam,y_max_cam;
float z_min_cam,z_max_cam;
//used for culling
for(int j=0;j<8;j++) {
float d_x=x_vec.dot(endpoints[j]);
float d_y=y_vec.dot(endpoints[j]);
float d_z=z_vec.dot(endpoints[j]);
if (j==0 || d_x<x_min)
x_min=d_x;
if (j==0 || d_x>x_max)
x_max=d_x;
if (j==0 || d_y<y_min)
y_min=d_y;
if (j==0 || d_y>y_max)
y_max=d_y;
if (j==0 || d_z<z_min)
z_min=d_z;
if (j==0 || d_z>z_max)
z_max=d_z;
}
{
//camera viewport stuff
//this trick here is what stabilizes the shadow (make potential jaggies to not move)
//at the cost of some wasted resolution. Still the quality increase is very well worth it
Vector3 center;
for(int j=0;j<8;j++) {
center+=endpoints[j];
}
center/=8.0;
//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;
float radius=0;
for(int j=0;j<8;j++) {
float d = center.distance_to(endpoints[j]);
if (d>radius)
radius=d;
}
radius *= texsize/(texsize-2.0); //add a texel by each side, so stepified texture will always fit
x_max_cam=x_vec.dot(center)+radius;
x_min_cam=x_vec.dot(center)-radius;
y_max_cam=y_vec.dot(center)+radius;
y_min_cam=y_vec.dot(center)-radius;
z_max_cam=z_vec.dot(center)+radius;
z_min_cam=z_vec.dot(center)-radius;
float unit = radius*2.0/texsize;
x_max_cam=Math::stepify(x_max_cam,unit);
x_min_cam=Math::stepify(x_min_cam,unit);
y_max_cam=Math::stepify(y_max_cam,unit);
y_min_cam=Math::stepify(y_min_cam,unit);
}
//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
Vector<Plane> light_frustum_planes;
light_frustum_planes.resize(6);
//right/left
light_frustum_planes[0]=Plane( x_vec, x_max );
light_frustum_planes[1]=Plane( -x_vec, -x_min );
//top/bottom
light_frustum_planes[2]=Plane( y_vec, y_max );
light_frustum_planes[3]=Plane( -y_vec, -y_min );
//near/far
light_frustum_planes[4]=Plane( z_vec, z_max+1e6 );
light_frustum_planes[5]=Plane( -z_vec, -z_min ); // z_min is ok, since casters further than far-light plane are not needed
int caster_cull_count = p_scenario->octree.cull_convex(light_frustum_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
// a pre pass will need to be needed to determine the actual z-near to be used
for(int j=0;j<caster_cull_count;j++) {
float min,max;
Instance *ins=instance_shadow_cull_result[j];
if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
continue;
ins->transformed_aabb.project_range_in_plane(Plane(z_vec,0),min,max);
if (max>z_max)
z_max=max;
}
{
CameraMatrix ortho_camera;
real_t half_x = (x_max_cam-x_min_cam) * 0.5;
real_t half_y = (y_max_cam-y_min_cam) * 0.5;
ortho_camera.set_orthogonal( -half_x, half_x,-half_y,half_y, 0, (z_max-z_min_cam) );
Transform ortho_transform;
ortho_transform.basis=p_light->data.transform.basis;
ortho_transform.origin=x_vec*(x_min_cam+half_x)+y_vec*(y_min_cam+half_y)+z_vec*z_max;
rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance, i, ortho_camera, ortho_transform,distances[i],distances[i+1] );
}
rasterizer->begin_shadow_map( p_light->light_info->instance, i );
for (int j=0;j<caster_cull_count;j++) {
Instance *instance = instance_shadow_cull_result[j];
if (!instance->visible || instance->data.cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
continue;
_instance_draw(instance);
}
rasterizer->end_shadow_map();
}
}
CameraMatrix _lispm_look( const Vector3 pos, const Vector3 dir, const Vector3 up) {
Vector3 dirN;
Vector3 upN;
Vector3 lftN;
lftN=dir.cross(up);
lftN.normalize();
upN=lftN.cross(dir);
upN.normalize();
dirN=dir.normalized();
CameraMatrix cmout;
float *output=&cmout.matrix[0][0];
output[ 0] = lftN[0];
output[ 1] = upN[0];
output[ 2] = -dirN[0];
output[ 3] = 0.0;
output[ 4] = lftN[1];
output[ 5] = upN[1];
output[ 6] = -dirN[1];
output[ 7] = 0.0;
output[ 8] = lftN[2];
output[ 9] = upN[2];
output[10] = -dirN[2];
output[11] = 0.0;
output[12] = -lftN.dot(pos);
output[13] = -upN.dot(pos);
output[14] = dirN.dot(pos);
output[15] = 1.0;
return cmout;
}
#if 1
void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
float near_dist=1;
Vector<Plane> light_frustum_planes = _camera_generate_orthogonal_planes(p_light,p_camera,p_cull_range.min,p_cull_range.max);
int caster_count = p_scenario->octree.cull_convex(light_frustum_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
// this could be faster by just getting supports from the AABBs..
// but, safer to do as the original implementation explains for now..
Vector<Vector3> caster_pointcloud;
caster_pointcloud.resize(caster_count*8);
int caster_pointcloud_size=0;
{
//fill pointcloud
Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
for(int i=0;i<caster_count;i++) {
Instance *ins = instance_shadow_cull_result[i];
if (!ins->visible || ins->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
continue;
for(int j=0;j<8;j++) {
Vector3 v = ins->aabb.get_endpoint(j);
v = ins->data.transform.xform(v);
caster_pointcloud_ptr[caster_pointcloud_size+j]=v;
}
caster_pointcloud_size+=8;
}
}
// now generate a pointcloud that contains the maximum bound (camera extruded by light)
Vector<Vector3> camera_pointcloud = _camera_generate_endpoints(p_light,p_camera,p_cull_range.min,p_cull_range.max);
int cpcsize=camera_pointcloud.size();
camera_pointcloud.resize( cpcsize*2 );
for(int i=0;i<cpcsize;i++) {
camera_pointcloud[i+cpcsize]=camera_pointcloud[i]-light_vec*1000;
}
// Vector<Vector3> frustum_points=_camera_generate_endpoints(p_light,p_camera,p_cull_range.min,p_cull_range.max);
// compute the "light-space" basis, using the algorithm described in the paper
// note: since bodyB is defined in eye space, all of these vectors should also be defined in eye space
Vector3 eye = p_camera->transform.origin;
Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
CameraMatrix light_space_basis = _lispm_look(eye,light_vec,up);
AABB light_space_aabb;
{ //create an optimal AABB from both the camera pointcloud and the objects pointcloud
AABB light_space_pointcloud_aabb;
AABB light_space_camera_aabb;
//xform pointcloud
const Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
for(int i=0;i<caster_pointcloud_size;i++) {
Vector3 p = light_space_basis.xform(caster_pointcloud_ptr[i]);
if (i==0) {
light_space_pointcloud_aabb.pos=p;
} else {
light_space_pointcloud_aabb.expand_to(p);
}
}
for(int i=0;i<camera_pointcloud.size();i++) {
Vector3 p = light_space_basis.xform(camera_pointcloud[i]);
if (i==0) {
light_space_camera_aabb.pos=p;
} else {
light_space_camera_aabb.expand_to(p);
}
}
light_space_aabb=light_space_pointcloud_aabb.intersection(light_space_camera_aabb);
}
float lvdp = light_vec.dot(view_vec);
float sin_gamma = Math::sqrt(1.0-lvdp*lvdp);
//use the formulas of the paper to get n (and f)
float factor = 1.0/sin_gamma;
float z_n = factor*near_dist; //often 1
float d = Math::abs(light_space_aabb.size.y); //perspective transform depth //light space y extents
float z_f = z_n + d*sin_gamma;
float n = (z_n+Math::sqrt(z_f*z_n))/sin_gamma;
float f = n+d;
Vector3 pos = eye - up*(n-near_dist);
CameraMatrix light_space_basis2 = _lispm_look(pos,light_vec,up);
//Transform light_space_basis2;
//light_space_basis2.set_look_at(pos,light_vec-pos,up);
//light_space_basis2.affine_invert();
//one possibility for a simple perspective transformation matrix
//with the two parameters n(near) and f(far) in y direction
CameraMatrix lisp_matrix;
lisp_matrix.matrix[1][1]=(f+n)/(f-n);
lisp_matrix.matrix[3][1]=-2*f*n/(f-n);
lisp_matrix.matrix[1][3]=1;
lisp_matrix.matrix[3][3]=0;
CameraMatrix projection = lisp_matrix * light_space_basis2;
//CameraMatrix projection = light_space_basis2 * lisp_matrix;
AABB proj_space_aabb;
{
AABB proj_space_pointcloud_aabb;
AABB proj_space_camera_aabb;
//xform pointcloud
Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
for(int i=0;i<caster_pointcloud_size;i++) {
Vector3 p = projection.xform(caster_pointcloud_ptr[i]);
if (i==0) {
proj_space_pointcloud_aabb.pos=p;
} else {
proj_space_pointcloud_aabb.expand_to(p);
}
}
for(int i=0;i<camera_pointcloud.size();i++) {
Vector3 p = projection.xform(camera_pointcloud[i]);
if (i==0) {
proj_space_camera_aabb.pos=p;
} else {
proj_space_camera_aabb.expand_to(p);
}
}
//proj_space_aabb=proj_space_pointcloud_aabb.intersection_with(proj_space_camera_aabb);
proj_space_aabb=proj_space_pointcloud_aabb;
}
projection.scale_translate_to_fit(proj_space_aabb);
projection=projection * lisp_matrix;
CameraMatrix scale;
scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
projection=scale * projection;
rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, projection , light_space_basis2.inverse() );
rasterizer->begin_shadow_map( p_light->light_info->instance, 0 );
for(int i=0;i<caster_count;i++) {
Instance *instance = instance_shadow_cull_result[i];
if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
continue;
_instance_draw(instance);
}
rasterizer->end_shadow_map();
}
#else
void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
/* STEP 1: GENERATE LIGHT TRANSFORM */
Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
float viewdot = Math::absf(light_vec.dot(view_vec));
Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
Transform light_transform;
light_transform.set_look_at(Vector3(),light_vec,up);
/* STEP 2: GENERATE WORDLSPACE PLANES AND VECTORS*/
float range_min=0.01; //p_cull_range.min
float range_max=20;//p_cull_range.max;
Vector<Vector3> camera_endpoints=_camera_generate_endpoints(p_light,p_camera,range_min,range_max); // frustum plane endpoints
ERR_FAIL_COND(camera_endpoints.empty());
// obtain the light frustm ranges (given endpoints)
Vector3 light_x_vec=light_transform.basis.get_axis( Vector3::AXIS_X ).normalized();
Vector3 light_y_vec=light_transform.basis.get_axis( Vector3::AXIS_Y ).normalized();
Vector3 light_z_vec=light_transform.basis.get_axis( Vector3::AXIS_Z ).normalized();
Vector3 light_axis_max;
Vector3 light_axis_min;
for(int j=0;j<8;j++) {
float d_x=light_x_vec.dot(camera_endpoints[j]);
float d_y=light_y_vec.dot(camera_endpoints[j]);
float d_z=light_z_vec.dot(camera_endpoints[j]);
if (j==0 || d_x<light_axis_min.x)
light_axis_min.x=d_x;
if (j==0 || d_x>light_axis_max.x)
light_axis_max.x=d_x;
if (j==0 || d_y<light_axis_min.y)
light_axis_min.y=d_y;
if (j==0 || d_y>light_axis_max.y)
light_axis_max.y=d_y;
if (j==0 || d_z<light_axis_min.z)
light_axis_min.z=d_z;
if (j==0 || d_z>light_axis_max.z)
light_axis_max.z=d_z;
}
//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
Vector<Plane> light_cull_planes;
light_cull_planes.resize(6);
//right/left
light_cull_planes[0]=Plane( light_x_vec, light_axis_max.x );
light_cull_planes[1]=Plane( -light_x_vec, -light_axis_min.x );
//top/bottom
light_cull_planes[2]=Plane( light_y_vec, light_axis_max.y );
light_cull_planes[3]=Plane( -light_y_vec, -light_axis_min.y );
//near/far
light_cull_planes[4]=Plane( light_z_vec, light_axis_max.z+1e6 );
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
/* STEP 3: CULL CASTERS */
int caster_count = p_scenario->octree.cull_convex(light_cull_planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
/* STEP 4: ADJUST FAR Z PLANE */
float caster_max_z=1e-1;
for(int i=0;i<caster_count;i++) {
Instance *ins=instance_shadow_cull_result[i];
if (!ins->visible || ins->cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
continue;
//@TODO optimize using support mapping
for(int j=0;j<8;j++) {
Vector3 v=ins->data.transform.xform(ins->aabb.get_endpoint(j));
float d = light_z_vec.dot(v);
if (d>caster_max_z)
caster_max_z=d;
}
}
float expand = caster_max_z-light_axis_max.z;
if (expand<0)
expand=0;
light_axis_max.z=MAX(caster_max_z,light_axis_max.z);
/* STEP 5: CREATE ORTHOGONAL PROJECTION */
CameraMatrix light_projection;
real_t half_x = (light_axis_max.x-light_axis_min.x) * 0.5;
real_t half_y = (light_axis_max.y-light_axis_min.y) * 0.5;
light_projection.set_orthogonal( -half_x, half_x,half_y, -half_y, 0, (light_axis_max.z-light_axis_min.z) );
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;
if (/*false &&*/ viewdot<0.96) {
float lvdp = light_vec.dot(view_vec);
float near_dist=1.0;
float sin_gamma = Math::sqrt(1.0-lvdp*lvdp);
//use the formulas of the paper to get n (and f)
float factor = 1.0/sin_gamma;
float z_n = factor*near_dist; //often 1
float d = Math::abs(light_axis_max.y-light_axis_min.y); //perspective transform depth //light space y extents
float z_f = z_n + d*sin_gamma;
float n = (z_n+Math::sqrt(z_f*z_n))/sin_gamma;
float f = n+d;
CameraMatrix lisp_matrix;
lisp_matrix.matrix[1][1]=(f+n)/(f-n);
lisp_matrix.matrix[3][1]=-2*f*n/(f-n);
lisp_matrix.matrix[1][3]=1;
lisp_matrix.matrix[3][3]=0;
Vector3 pos = p_camera->transform.origin - up*(n-near_dist);
CameraMatrix world2light = _lispm_look(pos,light_vec,up);
CameraMatrix projection = lisp_matrix * world2light;
AABB projection_bounds;
for(int i=0;i<camera_endpoints.size();i++) {
Vector3 p=camera_endpoints[i];
if (i==0)
projection_bounds.pos=projection.xform(p);
else
projection_bounds.expand_to(projection.xform(p));
projection_bounds.expand_to(projection.xform(p+light_vec*-expand));
}
CameraMatrix scaletrans;
scaletrans.scale_translate_to_fit(projection_bounds);
projection=scaletrans * lisp_matrix;
CameraMatrix scale;
scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
projection=scale * projection;
rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, projection, world2light.inverse(), viewdot);
} else {
//orthogonal
rasterizer->light_instance_set_shadow_transform(p_light->light_info->instance,0, light_projection , light_transform, viewdot);
}
rasterizer->begin_shadow_map( p_light->light_info->instance, 0 );
for(int i=0;i<caster_count;i++) {
Instance *instance = instance_shadow_cull_result[i];
if (!instance->visible || instance->cast_shadows==VS::SHADOW_CASTING_SETTING_OFF)
continue;
_instance_draw(instance);
}
rasterizer->end_shadow_map();
}
#endif
void VisualServerRaster::_light_instance_update_shadow(Instance *p_light,Scenario *p_scenario,Camera *p_camera,const CullRange& p_cull_range) {
if (!rasterizer->shadow_allocate_near( p_light->light_info->instance ))
return; // shadow could not be updated
/* VisualServerRaster supports for many shadow techniques, using the one the rasterizer requests */
Rasterizer::ShadowType shadow_type = rasterizer->light_instance_get_shadow_type(p_light->light_info->instance);
switch(shadow_type) {
case Rasterizer::SHADOW_SIMPLE: {
/* SPOT SHADOW */
rasterizer->begin_shadow_map( p_light->light_info->instance, 0 );
//using this one ensures that raster deferred will have it
float far = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
float angle = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_SPOT_ANGLE );
CameraMatrix cm;
cm.set_perspective( angle*2.0, 1.0, 0.001, far );
Vector<Plane> planes = cm.get_projection_planes(p_light->data.transform);
int cull_count = p_scenario->octree.cull_convex(planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
for (int i=0;i<cull_count;i++) {
Instance *instance = instance_shadow_cull_result[i];
if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
continue;
_instance_draw(instance);
}
rasterizer->end_shadow_map();
} break;
case Rasterizer::SHADOW_DUAL_PARABOLOID: {
/* OMNI SHADOW */
int passes = rasterizer->light_instance_get_shadow_passes( p_light->light_info->instance );
if (passes==2) {
for(int i=0;i<2;i++) {
rasterizer->begin_shadow_map( p_light->light_info->instance, i );
//using this one ensures that raster deferred will have it
float radius = rasterizer->light_get_var( p_light->base_rid, VS::LIGHT_PARAM_RADIUS);
float z =i==0?-1:1;
Vector<Plane> planes;
planes.resize(5);
planes[0]=p_light->data.transform.xform(Plane(Vector3(0,0,z),radius));
planes[1]=p_light->data.transform.xform(Plane(Vector3(1,0,z).normalized(),radius));
planes[2]=p_light->data.transform.xform(Plane(Vector3(-1,0,z).normalized(),radius));
planes[3]=p_light->data.transform.xform(Plane(Vector3(0,1,z).normalized(),radius));
planes[4]=p_light->data.transform.xform(Plane(Vector3(0,-1,z).normalized(),radius));
int cull_count = p_scenario->octree.cull_convex(planes,instance_shadow_cull_result,MAX_INSTANCE_CULL,INSTANCE_GEOMETRY_MASK);
for (int j=0;j<cull_count;j++) {
Instance *instance = instance_shadow_cull_result[j];
if (!instance->visible || instance->data.cast_shadows == VS::SHADOW_CASTING_SETTING_OFF)
continue;
_instance_draw(instance);
}
rasterizer->end_shadow_map();
}
} else if (passes==1) {
//one go
}
} break;
case Rasterizer::SHADOW_CUBE: {
// todo
} break;
case Rasterizer::SHADOW_ORTHOGONAL: {
_light_instance_update_pssm_shadow(p_light,p_scenario,p_camera,p_cull_range);
} break;
case Rasterizer::SHADOW_PSSM: {
_light_instance_update_pssm_shadow(p_light,p_scenario,p_camera,p_cull_range);
} break;
case Rasterizer::SHADOW_PSM: {
_light_instance_update_lispsm_shadow(p_light,p_scenario,p_camera,p_cull_range);
// todo
} break;
default: {}
}
}
void VisualServerRaster::_portal_disconnect(Instance *p_portal,bool p_cleanup) {
if (p_portal->portal_info->connected) {
//disconnect first
p_portal->portal_info->connected->portal_info->connected=NULL;
p_portal->portal_info->connected=NULL;
}
if (p_portal->room && p_portal->room->room) {
if (p_cleanup) {
p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
//p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
} else {
p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
}
}
}
void VisualServerRaster::_instance_validate_autorooms(Instance *p_geometry) {
if (p_geometry->auto_rooms.size()==0)
return;
p_geometry->valid_auto_rooms.clear();
int point_count = aabb_random_points.size();
const Vector3 * src_points = &aabb_random_points[0];
for(Set<Instance*>::Element *E=p_geometry->valid_auto_rooms.front();E;E=E->next()) {
Instance *room = E->get();
Vector3 *dst_points=&transformed_aabb_random_points[0];
//generate points
for(int i=0;i<point_count;i++) {
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));
}
int pass = room->room_info->room->bounds.get_points_inside(dst_points,point_count);
float ratio = pass;
if( point_count != 0 ) {
ratio /= (float)point_count;
}
if (ratio>0.5) // should make some constant
p_geometry->valid_auto_rooms.insert(room);
}
}
void VisualServerRaster::_portal_attempt_connect(Instance *p_portal) {
_portal_disconnect(p_portal);
Vector3 A_norm = p_portal->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
Plane A_plane( p_portal->data.transform.origin, A_norm );
float A_surface = p_portal->portal_info->portal->bounds.get_area();
if (A_surface==0)
return; //wtf
Instance *found=NULL;
Transform affine_inverse = p_portal->data.transform.affine_inverse();
for(Set<Instance*>::Element *E=p_portal->portal_info->candidate_set.front();E;E=E->next()) {
Instance *B = E->get();
if (B->portal_info->connected)
continue; // in use
Vector3 B_norm = B->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
// check that they are in front of another
float dot = A_norm.dot(-B_norm);
if (dot<0.707) // 45 degrees, TODO unharcode this
continue;
// check the max distance to the other portal
bool valid=true;
Rect2 local_bounds;
for(int i=0;i<B->portal_info->portal->shape.size();i++) {
Point2 point2 = B->portal_info->portal->shape[i];
Vector3 point = B->data.transform.xform( Vector3( point2.x, point2.y, 0 ) );
float dist = Math::abs(A_plane.distance_to(point));
if (
dist>p_portal->portal_info->portal->connect_range ||
dist>B->portal_info->portal->connect_range ) {
valid=false;
break;
}
Vector3 point_local = affine_inverse.xform(A_plane.project(point));
point2 = Point2(point_local.x,point_local.y);
if (i==0)
local_bounds.pos=point2;
else
local_bounds.expand_to(point2);
}
if (!valid)
continue;
float B_surface = B->portal_info->portal->bounds.get_area();
if (B_surface==0)
continue; //wtf
float clip_area = p_portal->portal_info->portal->bounds.clip(local_bounds).get_area();
//check that most of the area is shared
if ( (clip_area/A_surface) < 0.5 || (clip_area/B_surface) < 0.5) // TODO change for something else
continue;
found=B;
break;
}
if (!found) {
if (p_portal->room && p_portal->room->room) {
p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
}
return;
}
p_portal->portal_info->connected=found;
found->portal_info->connected=p_portal;
}
void* VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int) {
VisualServerRaster *self = (VisualServerRaster*)p_self;
Instance *A = p_A;
Instance *B = p_B;
if (A->base_type==INSTANCE_PORTAL) {
ERR_FAIL_COND_V( B->base_type!=INSTANCE_PORTAL,NULL );
A->portal_info->candidate_set.insert(B);
B->portal_info->candidate_set.insert(A);
self->_portal_attempt_connect(A);
//attempt to conncet portal A (will go through B anyway)
//this is a little hackish, but works fine in practice
} else if (A->base_type==INSTANCE_BAKED_LIGHT || B->base_type==INSTANCE_BAKED_LIGHT) {
if (B->base_type==INSTANCE_BAKED_LIGHT) {
SWAP(A,B);
}
ERR_FAIL_COND_V(B->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER,NULL);
B->baked_light_sampler_info->baked_lights.insert(A);
} else if (A->base_type==INSTANCE_ROOM || B->base_type==INSTANCE_ROOM) {
if (B->base_type==INSTANCE_ROOM)
SWAP(A,B);
ERR_FAIL_COND_V(! ((1<<B->base_type)&INSTANCE_GEOMETRY_MASK ),NULL);
B->auto_rooms.insert(A);
A->room_info->owned_autoroom_geometry.insert(B);
self->_instance_validate_autorooms(B);
} else {
if (B->base_type==INSTANCE_LIGHT) {
SWAP(A,B);
} else if (A->base_type!=INSTANCE_LIGHT) {
return NULL;
}
A->light_info->affected.insert(B);
B->lights.insert(A);
B->light_cache_dirty=true;
}
return NULL;
}
void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int,void*) {
VisualServerRaster *self = (VisualServerRaster*)p_self;
Instance *A = p_A;
Instance *B = p_B;
if (A->base_type==INSTANCE_PORTAL) {
ERR_FAIL_COND( B->base_type!=INSTANCE_PORTAL );
A->portal_info->candidate_set.erase(B);
B->portal_info->candidate_set.erase(A);
//after disconnecting them, see if they can connect again
self->_portal_attempt_connect(A);
self->_portal_attempt_connect(B);
} else if (A->base_type==INSTANCE_BAKED_LIGHT || B->base_type==INSTANCE_BAKED_LIGHT) {
if (B->base_type==INSTANCE_BAKED_LIGHT) {
SWAP(A,B);
}
ERR_FAIL_COND(B->base_type!=INSTANCE_BAKED_LIGHT_SAMPLER);
B->baked_light_sampler_info->baked_lights.erase(A);
} else if (A->base_type==INSTANCE_ROOM || B->base_type==INSTANCE_ROOM) {
if (B->base_type==INSTANCE_ROOM)
SWAP(A,B);
ERR_FAIL_COND(! ((1<<B->base_type)&INSTANCE_GEOMETRY_MASK ));
B->auto_rooms.erase(A);
B->valid_auto_rooms.erase(A);
A->room_info->owned_autoroom_geometry.erase(B);
}else {
if (B->base_type==INSTANCE_LIGHT) {
SWAP(A,B);
} else if (A->base_type!=INSTANCE_LIGHT) {
return;
}
A->light_info->affected.erase(B);
B->lights.erase(A);
B->light_cache_dirty=true;
}
}
bool VisualServerRaster::_test_portal_cull(Camera *p_camera, Instance *p_from_portal, Instance *p_to_portal) {
int src_point_count=p_from_portal->portal_info->transformed_point_cache.size();
int dst_point_count=p_to_portal->portal_info->transformed_point_cache.size();
if (src_point_count<2 || dst_point_count<2)
return false;
const Vector3 *src_points=&p_from_portal->portal_info->transformed_point_cache[0];
const Vector3 *dst_points=&p_to_portal->portal_info->transformed_point_cache[0];
bool outside=false;
bool clockwise = !p_from_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin);
for(int i=0;i<src_point_count;i++) {
const Vector3& point_prev = src_points[i?(i-1):(src_point_count-1)];
const Vector3& point = src_points[i];
Plane p = clockwise?Plane(p_camera->transform.origin,point,point_prev):Plane(p_camera->transform.origin,point_prev,point);
bool all_over=true;
for(int j=0;j<dst_point_count;j++) {
if (!p.is_point_over(dst_points[j])) {
all_over=false;
break;
}
}
if (all_over) {
outside=true;
break;
}
}
return !outside;
}
void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Instance *p_from_portal) {
ERR_FAIL_COND(!p_portal->scenario); //scenario outside
Instance *portal = p_portal;
if (!portal->room) {
return; //portals need all to belong to a room, it may be unconfigured yet
} else if (portal->last_render_pass!=render_pass) {
return; //invalid portal, ignore
} else if (portal->portal_info->last_visited_pass==render_pass) {
return; //portal already visited
} else if (portal==p_from_portal) {
return; // came from this portal, don't even bother testing
}
/* TEST DISABLE DISTANCE */
float disable_distance = p_portal->portal_info->portal->disable_distance;
if (disable_distance) {
//has disable distance..
float distance = p_camera->transform.origin.distance_to(portal->data.transform.origin);
if (disable_distance < distance) {
return;
}
}
/* TEST PORTAL NOT FACING OPTIMIZATION */
if (p_portal->portal_info->connected) {
//connected portal means, it must face against the camera to be seen
if (p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
return;
}
} else {
//disconencted portals (go from room to parent room or exterior) must face towards the canera
if (!p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
return;
}
}
if (p_from_portal && !_test_portal_cull(p_camera, p_from_portal, portal)) {
return; // portal not visible (culled)
}
portal->portal_info->last_visited_pass=render_pass;
if (portal->portal_info->connected) {
//interior<->interior portal
Instance *to_room = portal->portal_info->connected->room;
if (!to_room) {
return; //wtf.. oh well, connected to a roomless (invalid) portal
}
_cull_room(p_camera, to_room, portal->portal_info->connected);
} else {
//to exterior/to parent roomportal
Instance *parent_room = portal->room->room;
_cull_room(p_camera, parent_room, portal);
}
}
void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room,Instance *p_from_portal) {
if (p_room==NULL) {
//exterior
exterior_visited=true;
for(int i=0;i<exterior_portal_cull_count;i++) {
_cull_portal(p_camera, exterior_portal_cull_result[i],p_from_portal);
}
} else {
ERR_FAIL_COND(!p_room->scenario);
if (p_room->last_render_pass!=render_pass)
return; //this room is invalid
//interior
//first of all, validate the room
p_room->room_info->last_visited_pass=render_pass;
//see about going around portals
if (!p_room->room_info->room->occlude_exterior)
exterior_visited=true;
for(List<Instance*>::Element * E=p_room->room_info->owned_portal_instances.front();E;E=E->next()) {
_cull_portal(p_camera, E->get(),p_from_portal);
}
for(Set<Instance*>::Element * E=p_room->room_info->disconnected_child_portals.front();E;E=E->next()) {
_cull_portal(p_camera, E->get(),p_from_portal);
}
}
}
void VisualServerRaster::_process_sampled_light(const Transform& p_camera,Instance *p_sampled_light,bool p_linear_colorspace) {
BakedLightSampler *sampler_opts = p_sampled_light->baked_light_sampler_info->sampler;
int res = sampler_opts->resolution;
int dp_size = res*res*2;
Color * dp_map = (Color*)alloca( sizeof(Color)*dp_size); //allocate the dual parabolloid colors
Vector3 * dp_normals = (Vector3*)alloca( sizeof(Vector3)*dp_size); //allocate the dual parabolloid normals
const Vector3 * dp_src_normals = p_sampled_light->baked_light_sampler_info->sampler->dp_cache.ptr();
if (!p_sampled_light->baked_light_sampler_info->sampled_light.is_valid() || p_sampled_light->baked_light_sampler_info->resolution!=sampler_opts->resolution) {
if (p_sampled_light->baked_light_sampler_info->sampled_light.is_valid()) {
rasterizer->free(p_sampled_light->baked_light_sampler_info->sampled_light);
}
p_sampled_light->baked_light_sampler_info->resolution=sampler_opts->resolution;
p_sampled_light->baked_light_sampler_info->sampled_light=rasterizer->sampled_light_dp_create(sampler_opts->resolution,sampler_opts->resolution*2);
}
zeromem(dp_map,sizeof(Color)*dp_size);
bool valid=false;
int samples=0;
for(Set<Instance*>::Element *E=p_sampled_light->baked_light_sampler_info->baked_lights.front();E;E=E->next()) {
Instance *bl = E->get();
if (bl->baked_light_info->baked_light->sampler.size()==0)
continue; //not usable
Matrix3 norm_xform = bl->baked_light_info->affine_inverse.basis;//.inverse();
for(int i=0;i<dp_size;i++) {
dp_normals[i]=norm_xform.xform(dp_src_normals[i]).normalized();
}
//normals in place
//sample octree
float r = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_RADIUS];
float att = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_ATTENUATION];
float str = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_STRENGTH];
Vector3 s = p_sampled_light->data.transform.basis.get_scale();
r*=MAX(MAX(s.x,s.y),s.z);
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)));
//ok got octree local AABB
DVector<int>::Read rp = bl->baked_light_info->baked_light->sampler.read();
const int *rptr = rp.ptr();
int first = rptr[1];
int depth = rptr[2];
bool islinear = rptr[3]&1;
depth+=1;
AABB aabb;
aabb.pos.x=decode_float((const uint8_t*)&rptr[4]);
aabb.pos.y=decode_float((const uint8_t*)&rptr[5]);
aabb.pos.z=decode_float((const uint8_t*)&rptr[6]);
aabb.size.x=decode_float((const uint8_t*)&rptr[7]);
aabb.size.y=decode_float((const uint8_t*)&rptr[8]);
aabb.size.z=decode_float((const uint8_t*)&rptr[9]);
uint32_t *stack=(uint32_t*)alloca(depth*sizeof(uint32_t));
int *stack_ptr=(int*)alloca(depth*sizeof(int));
AABB *aabb_stack=(AABB*)alloca(depth*sizeof(AABB));
stack[0]=0;
stack_ptr[0]=first;
aabb_stack[0]=aabb;
Vector3 center = sample_aabb.pos + sample_aabb.size * 0.5;
int stack_pos=0;
Color max_col;
//int reso = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO];
int lalimit = sample_aabb.get_longest_axis_index();
float limit = sampler_opts->params[VS::BAKED_LIGHT_SAMPLER_DETAIL_RATIO]*sample_aabb.size[lalimit];
while(true) {
bool leaf = (rptr[ stack_ptr[stack_pos] ]>>16)==0;
if (aabb_stack[stack_pos].size[lalimit]<limit) {
leaf=true;
}
if (leaf) {
Vector3 from = aabb_stack[stack_pos].pos + aabb_stack[stack_pos].size * 0.5;
Vector3 norm = (from-center).normalized();
Color col;
col.r = ((rptr[ stack_ptr[stack_pos] ]&0xFFFF)/256.0);
col.g = ((rptr[ stack_ptr[stack_pos]+1 ]>>16)/256.0);
col.b = ((rptr[ stack_ptr[stack_pos]+1 ]&0xFFFF)/256.0);
max_col.r = MAX(max_col.r,col.r);
max_col.g = MAX(max_col.g,col.g);
max_col.b = MAX(max_col.b,col.b);
if (!islinear && p_linear_colorspace) {
col=col.to_linear();
}
float distance;
if (aabb_stack[stack_pos].has_point(center)) {
distance=0;
} else {
Vector3 support = aabb_stack[stack_pos].get_support(norm);
distance = Math::absf(norm.dot(support)-norm.dot(center));
}
if (distance>r)
distance=r;
float mult = Math::pow(1.0-distance/r,att)*str;
if (mult>0) {
col.r*=mult;
col.g*=mult;
col.b*=mult;
for(int i=0;i<dp_size;i++) {
float mult2 = norm.dot(dp_normals[i]);
if (mult2<0)
mult2=0;
Color col2(col.r*mult2,col.g*mult2,col.b*mult2,1.0);
dp_map[i].r=MAX(dp_map[i].r,col2.r);
dp_map[i].g=MAX(dp_map[i].g,col2.g);
dp_map[i].b=MAX(dp_map[i].b,col2.b);
}
}
samples++;
//nothing is valid unless you hit a leaf
valid=true;
stack_pos--;
} else if ((stack[stack_pos]&0xFF)<8) {
int i = stack[stack_pos]&0xFF;
int base = (stack[stack_pos]>>8);
if (!((rptr[ stack_ptr[stack_pos] ]>>16)&(1<<i))) {
//no bit, no test
stack[stack_pos]=(base<<8)+(i+1);
continue;
}
stack[stack_pos]=((base+1)<<8)+(i+1);
AABB child_aabb = aabb_stack[stack_pos];
child_aabb.size*=0.5;
if (i&1)
child_aabb.pos.x+=child_aabb.size.x;
if (i&2)
child_aabb.pos.y+=child_aabb.size.y;
if (i&4)
child_aabb.pos.z+=child_aabb.size.z;
if (!child_aabb.intersects(sample_aabb)) {
continue;
}
if (child_aabb.encloses(sample_aabb)) {
stack[stack_pos]=(base<<8)|8; //don't test the rest
}
stack_pos++;
ERR_FAIL_COND(stack_pos>=depth);
stack[stack_pos]=0;
stack_ptr[stack_pos]=rptr[ stack_ptr[stack_pos-1]+2+base ];
aabb_stack[stack_pos]=child_aabb;
} else {
stack_pos--;
if (stack_pos<0)
break;
}
}
}
//print_line("samples "+itos(samples) );
if (valid) {
for(int i=0;i<res;i++) {
//average seams to avoid aliasing
{
//top
int ofs1 = i;
int ofs2 = dp_size-res+i;
Color avg(
(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
1.0
);
dp_map[ofs1]=avg;
dp_map[ofs2]=avg;
}
{
//bottom
int ofs1 = res*res-res+i;
int ofs2 = res*res+i;
Color avg(
(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
1.0
);
dp_map[ofs1]=avg;
dp_map[ofs2]=avg;
}
{
//left
int ofs1 = i*res;
int ofs2 = res*res+(res-i-1)*res;
Color avg(
(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
1.0
);
dp_map[ofs1]=avg;
dp_map[ofs2]=avg;
}
{
//right
int ofs1 = i*res+(res-1);
int ofs2 = res*res+(res-i-1)*res+(res-1);
Color avg(
(dp_map[ofs1].r+dp_map[ofs2].r)*0.5,
(dp_map[ofs1].g+dp_map[ofs2].g)*0.5,
(dp_map[ofs1].b+dp_map[ofs2].b)*0.5,
1.0
);
dp_map[ofs1]=avg;
dp_map[ofs2]=avg;
}
}
rasterizer->sampled_light_dp_update(p_sampled_light->baked_light_sampler_info->sampled_light,dp_map,1.0);
for(Set<Instance*>::Element *F=p_sampled_light->baked_light_sampler_info->owned_instances.front();F;F=F->next()) {
F->get()->data.sampled_light=p_sampled_light->baked_light_sampler_info->sampled_light;
}
} else {
for(Set<Instance*>::Element *F=p_sampled_light->baked_light_sampler_info->owned_instances.front();F;F=F->next()) {
F->get()->data.sampled_light=RID(); //do not use because nothing close
}
}
/*
highp vec3 vtx = vertex_interp;
vtx.z*=dual_paraboloid.y; //side to affect
vtx.z+=0.01;
dp_clip=vtx.z;
highp float len=length( vtx );
vtx=normalize(vtx);
vtx.xy/=1.0+vtx.z;
vtx.z = len*dual_paraboloid.x; // it's a reciprocal(len - z_near) / (z_far - z_near);
vtx+=normalize(vtx)*0.025;
vtx.z = vtx.z * 2.0 - 1.0; // fit to clipspace
vertex_interp=vtx;
*/
}
void VisualServerRaster::_render_no_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario) {
RID environment;
if (p_scenario->environment.is_valid())
environment=p_scenario->environment;
else
environment=p_scenario->fallback_environment;
rasterizer->set_camera(Transform(),CameraMatrix(),false);
rasterizer->begin_scene(p_viewport->viewport_data,environment,p_scenario->debug);
rasterizer->set_viewport(viewport_rect);
rasterizer->end_scene();
}
void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario) {
render_pass++;
uint32_t camera_layer_mask=p_camera->visible_layers;
/* STEP 1 - SETUP CAMERA */
CameraMatrix camera_matrix;
bool ortho=false;
switch(p_camera->type) {
case Camera::ORTHOGONAL: {
camera_matrix.set_orthogonal(
p_camera->size,
viewport_rect.width / (float)viewport_rect.height,
p_camera->znear,
p_camera->zfar,
p_camera->vaspect
);
ortho=true;
} break;
case Camera::PERSPECTIVE: {
camera_matrix.set_perspective(
p_camera->fov,
viewport_rect.width / (float)viewport_rect.height,
p_camera->znear,
p_camera->zfar,
p_camera->vaspect
);
ortho=false;
} break;
}
rasterizer->set_camera(p_camera->transform, camera_matrix,ortho);
Vector<Plane> planes = camera_matrix.get_projection_planes(p_camera->transform);
CullRange cull_range; // cull range is used for PSSM, and having an idea of the rendering depth
cull_range.nearp=Plane(p_camera->transform.origin,-p_camera->transform.basis.get_axis(2).normalized());
cull_range.z_near=camera_matrix.get_z_near();
cull_range.z_far=camera_matrix.get_z_far();
cull_range.min=cull_range.z_far;
cull_range.max=cull_range.z_near;
/* STEP 2 - CULL */
int cull_count = p_scenario->octree.cull_convex(planes,instance_cull_result,MAX_INSTANCE_CULL);
light_cull_count=0;
light_samplers_culled=0;
/* print_line("OT: "+rtos( (OS::get_singleton()->get_ticks_usec()-t)/1000.0));
print_line("OTO: "+itos(p_scenario->octree.get_octant_count()));
// print_line("OTE: "+itos(p_scenario->octree.get_elem_count()));
print_line("OTP: "+itos(p_scenario->octree.get_pair_count()));
*/
/* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
// compute portals
exterior_visited=false;
exterior_portal_cull_count=0;
if (room_cull_enabled) {
for(int i=0;i<cull_count;i++) {
Instance *ins = instance_cull_result[i];
ins->last_render_pass=render_pass;
if (ins->base_type!=INSTANCE_PORTAL)
continue;
if (ins->room)
continue;
ERR_CONTINUE(exterior_portal_cull_count>=MAX_EXTERIOR_PORTALS);
exterior_portal_cull_result[exterior_portal_cull_count++]=ins;
}
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));
Set<Instance*> current_rooms;
Set<Instance*> portal_rooms;
//add to set
for(int i=0;i<room_cull_count;i++) {
if (room_cull_result[i]->base_type==INSTANCE_ROOM) {
current_rooms.insert(room_cull_result[i]);
}
if (room_cull_result[i]->base_type==INSTANCE_PORTAL) {
//assume inside that room if also inside the portal..
if (room_cull_result[i]->room) {
portal_rooms.insert(room_cull_result[i]->room);
}
SWAP(room_cull_result[i],room_cull_result[room_cull_count-1]);
room_cull_count--;
i--;
}
}
//remove from set if it has a parent room or BSP doesn't contain
for(int i=0;i<room_cull_count;i++) {
Instance *r = room_cull_result[i];
//check inside BSP
Vector3 room_local_point = r->room_info->affine_inverse.xform( p_camera->transform.origin );
if (!portal_rooms.has(r) && !r->room_info->room->bounds.point_is_inside(room_local_point)) {
current_rooms.erase(r);
continue;
}
//check parent
while (r->room) {// has parent room
current_rooms.erase(r);
r=r->room;
}
}
if (current_rooms.size()) {
//camera is inside a room
// go through rooms
for(Set<Instance*>::Element *E=current_rooms.front();E;E=E->next()) {
_cull_room(p_camera,E->get());
}
} else {
//start from exterior
_cull_room(p_camera,NULL);
}
}
/* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
for(int i=0;i<cull_count;i++) {
Instance *ins = instance_cull_result[i];
bool keep=false;
if ((camera_layer_mask&ins->layer_mask)==0) {
//failure
} else if (ins->base_type==INSTANCE_LIGHT) {
if (light_cull_count<MAX_LIGHTS_CULLED) {
light_cull_result[light_cull_count++]=ins;
// rasterizer->light_instance_set_active_hint(ins->light_info->instance);
{
//compute distance to camera using aabb support
Vector3 n = ins->data.transform.basis.xform_inv(cull_range.nearp.normal).normalized();
Vector3 s = ins->data.transform.xform(ins->aabb.get_support(n));
ins->light_info->dtc=cull_range.nearp.distance_to(s);
}
}
} else if ((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK && ins->visible && ins->data.cast_shadows!=VS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
bool discarded=false;
if (ins->draw_range_end>0) {
float d = cull_range.nearp.distance_to(ins->data.transform.origin);
if (d<0)
d=0;
discarded=(d<ins->draw_range_begin || d>=ins->draw_range_end);
}
if (!discarded) {
// test if this geometry should be visible
if (room_cull_enabled) {
if (ins->visible_in_all_rooms) {
keep=true;
} else if (ins->room) {
if (ins->room->room_info->last_visited_pass==render_pass)
keep=true;
} else if (ins->auto_rooms.size()) {
for(Set<Instance*>::Element *E=ins->auto_rooms.front();E;E=E->next()) {
if (E->get()->room_info->last_visited_pass==render_pass) {
keep=true;
break;
}
}
} else if(exterior_visited)
keep=true;
} else {
keep=true;
}
}
if (keep) {
// update cull range
float min,max;
ins->transformed_aabb.project_range_in_plane(cull_range.nearp,min,max);
if (min<cull_range.min)
cull_range.min=min;
if (max>cull_range.max)
cull_range.max=max;
if (ins->sampled_light && ins->sampled_light->baked_light_sampler_info->last_pass!=render_pass) {
if (light_samplers_culled<MAX_LIGHT_SAMPLERS) {
light_sampler_cull_result[light_samplers_culled++]=ins->sampled_light;
ins->sampled_light->baked_light_sampler_info->last_pass=render_pass;
}
}
}
}
if (!keep) {
// remove, no reason to keep
cull_count--;
SWAP( instance_cull_result[i], instance_cull_result[ cull_count ] );
i--;
ins->last_render_pass=0; // make invalid
} else {
ins->last_render_pass=render_pass;
}
}
if (cull_range.max > cull_range.z_far )
cull_range.max=cull_range.z_far;
if (cull_range.min < cull_range.z_near )
cull_range.min=cull_range.z_near;
/* STEP 5 - PROCESS LIGHTS */
rasterizer->shadow_clear_near(); //clear near shadows, will be recreated
// directional lights
{
List<RID>::Element *E=p_scenario->directional_lights.front();
while(E) {
Instance *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
if (light && light->light_info->enabled && rasterizer->light_has_shadow(light->base_rid)) {
//rasterizer->light_instance_set_active_hint(light->light_info->instance);
_light_instance_update_shadow(light,p_scenario,p_camera,cull_range);
}
E=E->next();
}
}
//discard lights not affecting anything (useful for deferred rendering, shadowmaps, etc)
for (int i=0;i<light_cull_count;i++) {
Instance *ins = light_cull_result[i];
if (light_discard_enabled) {
//see if the light should be pre discarded because no one is seeing it
//this test may seem expensive, but in reality, it shouldn't be
//because of early out condition. It will only go through everything
//if it's being discarded.
bool valid=false;
InstanceSet::Element *E =ins->light_info->affected.front();
while(E) {
if (E->get()->last_render_pass==render_pass) {
valid=true; // early out.
break;
}
E=E->next();
}
if (!valid) {
light_cull_count--;
SWAP( light_cull_result[i], light_cull_result[ light_cull_count ] );
i--;
}
}
}
{ //this should eventually change to
//assign shadows by distance to camera
SortArray<Instance*,_InstanceLightsort> sorter;
sorter.sort(light_cull_result,light_cull_count);
for (int i=0;i<light_cull_count;i++) {
Instance *ins = light_cull_result[i];
if (!rasterizer->light_has_shadow(ins->base_rid) || !shadows_enabled)
continue;
/* for far shadows?
if (ins->version == ins->light_info->last_version && rasterizer->light_instance_has_far_shadow(ins->light_info->instance))
continue; // didn't change
*/
_light_instance_update_shadow(ins,p_scenario,p_camera,cull_range);
ins->light_info->last_version=ins->version;
}
}
/* ENVIRONMENT */
RID environment;
if (p_camera->env.is_valid()) //camera has more environment priority
environment=p_camera->env;
else if (p_scenario->environment.is_valid())
environment=p_scenario->environment;
else
environment=p_scenario->fallback_environment;
/* STEP 6 - SAMPLE BAKED LIGHT */
bool islinear =false;
if (environment.is_valid()) {
islinear = rasterizer->environment_is_fx_enabled(environment,VS::ENV_FX_SRGB);
}
for(int i=0;i<light_samplers_culled;i++) {
_process_sampled_light(p_camera->transform,light_sampler_cull_result[i],islinear);
}
/* STEP 7 - PROCESS GEOMETRY AND DRAW SCENE*/
rasterizer->begin_scene(p_viewport->viewport_data,environment,p_scenario->debug);
rasterizer->set_viewport(viewport_rect);
// add lights
{
List<RID>::Element *E=p_scenario->directional_lights.front();
for(;E;E=E->next()) {
Instance *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
ERR_CONTINUE(!light);
if (!light->light_info->enabled)
continue;
rasterizer->add_light(light->light_info->instance);
light->light_info->last_add_pass=render_pass;
}
for (int i=0;i<light_cull_count;i++) {
Instance *ins = light_cull_result[i];
rasterizer->add_light(ins->light_info->instance);
ins->light_info->last_add_pass=render_pass;
}
}
// add geometry
for(int i=0;i<cull_count;i++) {
Instance *ins = instance_cull_result[i];
ERR_CONTINUE(!((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK));
_instance_draw(ins);
}
rasterizer->end_scene();
}
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) {
static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
Rasterizer::CanvasItem *z_list[z_range];
Rasterizer::CanvasItem *z_last_list[z_range];
for(int i=0;i<z_range;i++) {
z_list[i]=NULL;
z_last_list[i]=NULL;
}
_render_canvas_item(p_canvas_item,p_transform,p_clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
for(int i=0;i<z_range;i++) {
if (!z_list[i])
continue;
rasterizer->canvas_render_items(z_list[i],CANVAS_ITEM_Z_MIN+i,p_modulate,p_lights);
}
}
void VisualServerRaster::_render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect) {
VisualServerRaster *self=(VisualServerRaster*)(p_self);
Viewport *vp=(Viewport*)p_vp;
self->_draw_viewport(vp,p_rect.pos.x,p_rect.pos.y,p_rect.size.x,p_rect.size.y);
self->rasterizer->canvas_begin();
}
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) {
CanvasItem *ci = p_canvas_item;
if (!ci->visible)
return;
if (p_opacity<0.007)
return;
Rect2 rect = ci->get_rect();
Matrix32 xform = p_transform * ci->xform;
Rect2 global_rect = xform.xform(rect);
global_rect.pos+=p_clip_rect.pos;
if (global_rect.intersects(p_clip_rect) && ci->viewport.is_valid() && viewport_owner.owns(ci->viewport)) {
Viewport *vp = viewport_owner.get(ci->viewport);
Point2i from = xform.get_origin() + Point2(viewport_rect.x,viewport_rect.y);
Point2i size = rect.size;
size.x *= xform[0].length();
size.y *= xform[1].length();
ci->vp_render = memnew( Rasterizer::CanvasItem::ViewportRender );
ci->vp_render->owner=this;
ci->vp_render->udata=vp;
ci->vp_render->rect=Rect2(from.x,
from.y,
size.x,
size.y);
/*
_draw_viewport(vp,
from.x,
from.y,
size.x,
size.y);
*/
//rasterizer->canvas_begin();
} else {
ci->vp_render=NULL;
}
if (ci->use_parent_material && p_material_owner)
ci->material_owner=p_material_owner;
else {
p_material_owner=ci;
ci->material_owner=NULL;
}
float opacity = ci->opacity * p_opacity;
int child_item_count=ci->child_items.size();
CanvasItem **child_items=(CanvasItem**)alloca(child_item_count*sizeof(CanvasItem*));
copymem(child_items,ci->child_items.ptr(),child_item_count*sizeof(CanvasItem*));
if (ci->clip) {
if (p_canvas_clip != NULL) {
ci->final_clip_rect=p_canvas_clip->final_clip_rect.clip(global_rect);
} else {
ci->final_clip_rect=global_rect;
}
ci->final_clip_owner=ci;
} else {
ci->final_clip_owner=p_canvas_clip;
}
if (ci->sort_y) {
SortArray<CanvasItem*,CanvasItemPtrSort> sorter;
sorter.sort(child_items,child_item_count);
}
if (ci->z_relative)
p_z=CLAMP(p_z+ci->z,CANVAS_ITEM_Z_MIN,CANVAS_ITEM_Z_MAX);
else
p_z=ci->z;
for(int i=0;i<child_item_count;i++) {
if (child_items[i]->ontop)
continue;
_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);
}
if (ci->copy_back_buffer) {
ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
}
if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect)) || ci->vp_render || ci->copy_back_buffer) {
//something to draw?
ci->final_transform=xform;
ci->final_opacity=opacity * ci->self_opacity;
ci->global_rect_cache=global_rect;
ci->global_rect_cache.pos-=p_clip_rect.pos;
ci->light_masked=false;
int zidx = p_z-CANVAS_ITEM_Z_MIN;
if (z_last_list[zidx]) {
z_last_list[zidx]->next=ci;
z_last_list[zidx]=ci;
} else {
z_list[zidx]=ci;
z_last_list[zidx]=ci;
}
ci->next=NULL;
}
for(int i=0;i<child_item_count;i++) {
if (!child_items[i]->ontop)
continue;
_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);
}
}
void VisualServerRaster::_light_mask_canvas_items(int p_z,Rasterizer::CanvasItem *p_canvas_item,Rasterizer::CanvasLight *p_masked_lights) {
if (!p_masked_lights)
return;
Rasterizer::CanvasItem *ci=p_canvas_item;
while(ci) {
Rasterizer::CanvasLight *light=p_masked_lights;
while(light) {
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)) {
ci->light_masked=true;
}
light=light->mask_next_ptr;
}
ci=ci->next;
}
}
void VisualServerRaster::_render_canvas(Canvas *p_canvas,const Matrix32 &p_transform,Rasterizer::CanvasLight *p_lights,Rasterizer::CanvasLight *p_masked_lights) {
rasterizer->canvas_begin();
int l = p_canvas->child_items.size();
Canvas::ChildItem *ci=p_canvas->child_items.ptr();
bool has_mirror=false;
for(int i=0;i<l;i++) {
if (ci[i].mirror.x || ci[i].mirror.y) {
has_mirror=true;
break;
}
}
Rect2 clip_rect(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height);
if (!has_mirror) {
static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
Rasterizer::CanvasItem *z_list[z_range];
Rasterizer::CanvasItem *z_last_list[z_range];
for(int i=0;i<z_range;i++) {
z_list[i]=NULL;
z_last_list[i]=NULL;
}
for(int i=0;i<l;i++) {
_render_canvas_item(ci[i].item,p_transform,clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
}
for(int i=0;i<z_range;i++) {
if (!z_list[i])
continue;
if (p_masked_lights) {
_light_mask_canvas_items(CANVAS_ITEM_Z_MIN+i,z_list[i],p_masked_lights);
}
rasterizer->canvas_render_items(z_list[i],CANVAS_ITEM_Z_MIN+i,p_canvas->modulate,p_lights);
}
} else {
for(int i=0;i<l;i++) {
Canvas::ChildItem& ci=p_canvas->child_items[i];
_render_canvas_item_tree(ci.item,p_transform,clip_rect,p_canvas->modulate,p_lights);
//mirroring (useful for scrolling backgrounds)
if (ci.mirror.x!=0) {
Matrix32 xform2 = p_transform * Matrix32(0,Vector2(ci.mirror.x,0));
_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
}
if (ci.mirror.y!=0) {
Matrix32 xform2 = p_transform * Matrix32(0,Vector2(0,ci.mirror.y));
_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
}
if (ci.mirror.y!=0 && ci.mirror.x!=0) {
Matrix32 xform2 = p_transform * Matrix32(0,ci.mirror);
_render_canvas_item_tree(ci.item,xform2,clip_rect,p_canvas->modulate,p_lights);
}
}
}
}
void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport,bool p_ignore_camera) {
Camera *camera=NULL;
if (camera_owner.owns( p_viewport->camera ))
camera=camera_owner.get( p_viewport->camera );
Scenario *scenario = scenario_owner.get( p_viewport->scenario );
_update_instances(); // check dirty instances before rendering
if (p_ignore_camera)
_render_no_camera(p_viewport, camera,scenario );
else
_render_camera(p_viewport, camera,scenario );
}
void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_ofs_y,int p_parent_w,int p_parent_h) {
ViewportRect desired_rect=p_viewport->rect;
ViewportRect old_rect = viewport_rect;
// bool vpchanged=false;
// convert default expanding viewports to actual size
//if (desired_rect.x==0 && desired_rect.y==0 && desired_rect.width==0 && desired_rect.height==0) {
if (p_parent_w != 0 && p_parent_h != 0) {
desired_rect.width=p_parent_w;
desired_rect.height=p_parent_h;
}
ERR_FAIL_COND(desired_rect.width<=0 || desired_rect.height<=0);
desired_rect.x+=p_ofs_x;
desired_rect.y+=p_ofs_y;
// if the viewport is different than the actual one, change it
if ( p_viewport->render_target.is_valid() || viewport_rect.x != desired_rect.x ||
viewport_rect.y != desired_rect.y ||
viewport_rect.width != desired_rect.width ||
viewport_rect.height != desired_rect.height ) {
viewport_rect=desired_rect;
rasterizer->set_viewport(viewport_rect);
}
/* Camera should always be BEFORE any other 3D */
bool scenario_draw_canvas_bg=false;
int scenario_canvas_max_layer=0;
if (!p_viewport->hide_canvas && !p_viewport->disable_environment && scenario_owner.owns(p_viewport->scenario)) {
Scenario *scenario=scenario_owner.get(p_viewport->scenario);
if (scenario->environment.is_valid()) {
if (rasterizer->is_environment(scenario->environment)) {
scenario_draw_canvas_bg=rasterizer->environment_get_background(scenario->environment)==VS::ENV_BG_CANVAS;
scenario_canvas_max_layer=rasterizer->environment_get_background_param(scenario->environment,VS::ENV_BG_PARAM_CANVAS_MAX_LAYER);
}
}
}
bool can_draw_3d=!p_viewport->hide_scenario && camera_owner.owns(p_viewport->camera) && scenario_owner.owns(p_viewport->scenario);
if (scenario_draw_canvas_bg) {
rasterizer->begin_canvas_bg();
}
if (!scenario_draw_canvas_bg && can_draw_3d) {
_draw_viewport_camera(p_viewport,false);
} else if (true /*|| !p_viewport->canvas_list.empty()*/){
//clear the viewport black because of no camera? i seriously should..
if (p_viewport->render_target_clear_on_new_frame || p_viewport->render_target_clear) {
if (p_viewport->transparent_bg) {
rasterizer->clear_viewport(Color(0,0,0,0));
}
else {
Color cc=clear_color;
if (scenario_draw_canvas_bg)
cc.a=0;
rasterizer->clear_viewport(cc);
}
p_viewport->render_target_clear=false;
}
}
if (!p_viewport->hide_canvas) {
int i=0;
Map<Viewport::CanvasKey,Viewport::CanvasData*> canvas_map;
Rect2 clip_rect(0,0,viewport_rect.width,viewport_rect.height);
Rasterizer::CanvasLight *lights=NULL;
Rasterizer::CanvasLight *lights_with_shadow=NULL;
Rasterizer::CanvasLight *lights_with_mask=NULL;
Rect2 shadow_rect;
int light_count=0;
for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
Matrix32 xf = p_viewport->global_transform * E->get().transform;
//find lights in canvas
for(Set<Rasterizer::CanvasLight*>::Element *F=E->get().canvas->lights.front();F;F=F->next()) {
Rasterizer::CanvasLight* cl=F->get();
if (cl->enabled && cl->texture.is_valid()) {
//not super efficient..
Size2 tsize(rasterizer->texture_get_width(cl->texture),rasterizer->texture_get_height(cl->texture));
tsize*=cl->scale;
Vector2 offset=tsize/2.0;
cl->rect_cache=Rect2(-offset+cl->texture_offset,tsize);
cl->xform_cache=xf * cl->xform;
if (clip_rect.intersects_transformed(cl->xform_cache,cl->rect_cache)) {
cl->filter_next_ptr=lights;
lights=cl;
cl->texture_cache=NULL;
Matrix32 scale;
scale.scale(cl->rect_cache.size);
scale.elements[2]=cl->rect_cache.pos;
cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse();
cl->light_shader_pos=cl->xform_cache[2];
if (cl->shadow_buffer.is_valid()) {
cl->shadows_next_ptr=lights_with_shadow;
if (lights_with_shadow==NULL) {
shadow_rect = cl->xform_cache.xform(cl->rect_cache);
} else {
shadow_rect=shadow_rect.merge( cl->xform_cache.xform(cl->rect_cache) );
}
lights_with_shadow=cl;
cl->radius_cache=cl->rect_cache.size.length();
}
if (cl->mode==CANVAS_LIGHT_MODE_MASK) {
cl->mask_next_ptr=lights_with_mask;
lights_with_mask=cl;
}
light_count++;
}
}
}
//print_line("lights: "+itos(light_count));
canvas_map[ Viewport::CanvasKey( E->key(), E->get().layer) ]=&E->get();
}
if (lights_with_shadow) {
//update shadows if any
Rasterizer::CanvasLightOccluderInstance * occluders=NULL;
//make list of occluders
for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
Matrix32 xf = p_viewport->global_transform * E->get().transform;
for(Set<Rasterizer::CanvasLightOccluderInstance*>::Element *F=E->get().canvas->occluders.front();F;F=F->next()) {
if (!F->get()->enabled)
continue;
F->get()->xform_cache = xf * F->get()->xform;
if (shadow_rect.intersects_transformed(F->get()->xform_cache,F->get()->aabb_cache)) {
F->get()->next=occluders;
occluders=F->get();
}
}
}
//update the light shadowmaps with them
Rasterizer::CanvasLight *light=lights_with_shadow;
while(light) {
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);
light=light->shadows_next_ptr;
}
rasterizer->set_viewport(viewport_rect); //must reset viewport afterwards
}
if (scenario_draw_canvas_bg && canvas_map.front() && canvas_map.front()->key().layer>scenario_canvas_max_layer) {
_draw_viewport_camera(p_viewport,!can_draw_3d);
scenario_draw_canvas_bg=false;
}
for (Map<Viewport::CanvasKey,Viewport::CanvasData*>::Element *E=canvas_map.front();E;E=E->next()) {
// print_line("canvas "+itos(i)+" size: "+itos(I->get()->canvas->child_items.size()));
//print_line("GT "+p_viewport->global_transform+". CT: "+E->get()->transform);
Matrix32 xform = p_viewport->global_transform * E->get()->transform;
Rasterizer::CanvasLight *canvas_lights=NULL;
Rasterizer::CanvasLight *ptr=lights;
while(ptr) {
if (E->get()->layer>=ptr->layer_min && E->get()->layer<=ptr->layer_max) {
ptr->next_ptr=canvas_lights;
canvas_lights=ptr;
}
ptr=ptr->filter_next_ptr;
}
_render_canvas( E->get()->canvas,xform,canvas_lights,lights_with_mask );
i++;
if (scenario_draw_canvas_bg && E->key().layer>=scenario_canvas_max_layer) {
_draw_viewport_camera(p_viewport,!can_draw_3d);
scenario_draw_canvas_bg=false;
}
}
if (scenario_draw_canvas_bg) {
_draw_viewport_camera(p_viewport,!can_draw_3d);
scenario_draw_canvas_bg=false;
}
// rasterizer->canvas_debug_viewport_shadows(lights_with_shadow);
}
//capture
if (p_viewport->queue_capture) {
rasterizer->capture_viewport(&p_viewport->capture);
p_viewport->queue_capture = false;
}
//restore
if ( viewport_rect.x != old_rect.x ||
viewport_rect.y != old_rect.y ||
viewport_rect.width != old_rect.width ||
viewport_rect.height != old_rect.height ) {
viewport_rect=old_rect;
rasterizer->set_viewport(viewport_rect);
}
}
void VisualServerRaster::_draw_viewports() {
//draw viewports for render targets
List<Viewport*> to_blit;
List<Viewport*> to_disable;
for(SelfList<Viewport> *E=viewport_update_list.first();E;E=E->next()) {
Viewport *vp = E->self();
ERR_CONTINUE(!vp);
if (
vp->render_target_update_mode==RENDER_TARGET_UPDATE_WHEN_VISIBLE &&
!vp->rendered_in_prev_frame &&
!vp->queue_capture
) {
continue;
}
if (vp->rt_to_screen_rect!=Rect2())
to_blit.push_back(vp);
rasterizer->set_render_target(vp->render_target,vp->transparent_bg,vp->render_target_vflip);
_draw_viewport(vp,0,0,vp->rect.width,vp->rect.height);
if ( (vp->queue_capture && vp->render_target_update_mode==RENDER_TARGET_UPDATE_DISABLED) || vp->render_target_update_mode==RENDER_TARGET_UPDATE_ONCE) {
//was only enabled for capture
to_disable.push_back(vp);
vp->render_target_update_mode=RENDER_TARGET_UPDATE_DISABLED;
}
}
rasterizer->set_render_target(RID());
while(to_disable.size()) {
//disable again because it was only for capture
viewport_update_list.remove(&to_disable.front()->get()->update_list);
to_disable.pop_front();
}
//draw RTs directly to screen when requested
for (List<Viewport*>::Element *E=to_blit.front();E;E=E->next()) {
int window_w = OS::get_singleton()->get_video_mode().width;
int window_h = OS::get_singleton()->get_video_mode().height;
ViewportRect desired_rect;
desired_rect.x = desired_rect.y = 0;
desired_rect.width = window_w;
desired_rect.height = window_h;
if ( viewport_rect.x != desired_rect.x ||
viewport_rect.y != desired_rect.y ||
viewport_rect.width != desired_rect.width ||
viewport_rect.height != desired_rect.height ) {
viewport_rect=desired_rect;
rasterizer->set_viewport(viewport_rect);
}
rasterizer->canvas_begin();
rasterizer->canvas_disable_blending();
rasterizer->canvas_begin_rect(Matrix32());
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));
}
//draw viewports attached to screen
for(Map<RID,int>::Element *E=screen_viewports.front();E;E=E->next()) {
Viewport *vp = viewport_owner.get(E->key());
ERR_CONTINUE(!vp);
int window_w = OS::get_singleton()->get_video_mode(E->get()).width;
int window_h = OS::get_singleton()->get_video_mode(E->get()).height;
Rect2 r(0,0,vp->rect.width,vp->rect.height);
if (r.size.width==0)
r.size.width=window_w;
if (r.size.height==0)
r.size.height=window_h;
_draw_viewport(vp,r.pos.x,r.pos.y,r.size.width,r.size.height);
}
//check when a viewport associated to a render target was drawn
for(SelfList<Viewport> *E=viewport_update_list.first();E;E=E->next()) {
Viewport *vp = E->self();
ERR_CONTINUE(!vp);
if (vp->render_target_update_mode!=RENDER_TARGET_UPDATE_WHEN_VISIBLE)
continue;
vp->rendered_in_prev_frame=rasterizer->render_target_renedered_in_frame(vp->render_target);
}
}
void VisualServerRaster::_draw_cursors_and_margins() {
int window_w = OS::get_singleton()->get_video_mode().width;
int window_h = OS::get_singleton()->get_video_mode().height;
ViewportRect desired_rect;
desired_rect.x = desired_rect.y = 0;
desired_rect.width = window_w;
desired_rect.height = window_h;
if ( viewport_rect.x != desired_rect.x ||
viewport_rect.y != desired_rect.y ||
viewport_rect.width != desired_rect.width ||
viewport_rect.height != desired_rect.height ) {
viewport_rect=desired_rect;
rasterizer->set_viewport(viewport_rect);
}
rasterizer->canvas_begin();
rasterizer->canvas_begin_rect(Matrix32());
for (int i=0; i<MAX_CURSORS; i++) {
if (!cursors[i].visible) {
continue;
};
RID tex = cursors[i].texture?cursors[i].texture:default_cursor_texture;
ERR_CONTINUE( !tex );
if (cursors[i].region.has_no_area()) {
Point2 size(texture_get_width(tex), texture_get_height(tex));
rasterizer->canvas_draw_rect(Rect2(cursors[i].pos, size), 0, Rect2(), tex, Color(1, 1, 1, 1));
} else {
Point2 size = cursors[i].region.size;
rasterizer->canvas_draw_rect(Rect2(cursors[i].pos, size), Rasterizer::CANVAS_RECT_REGION, cursors[i].region, tex, Color(1, 1, 1, 1));
}
};
if (black_image[MARGIN_LEFT].is_valid()) {
Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_LEFT]),rasterizer->texture_get_height(black_image[MARGIN_LEFT]));
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));
} else if (black_margin[MARGIN_LEFT])
rasterizer->canvas_draw_rect(Rect2(0,0,black_margin[MARGIN_LEFT],window_h),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
if (black_image[MARGIN_RIGHT].is_valid()) {
Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_RIGHT]),rasterizer->texture_get_height(black_image[MARGIN_RIGHT]));
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));
} else if (black_margin[MARGIN_RIGHT])
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));
if (black_image[MARGIN_TOP].is_valid()) {
Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_TOP]),rasterizer->texture_get_height(black_image[MARGIN_TOP]));
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));
} else if (black_margin[MARGIN_TOP]) {
rasterizer->canvas_draw_rect(Rect2(0,0,window_w,black_margin[MARGIN_TOP]),0,Rect2(0,0,1,1),RID(),Color(0,0,0));
}
if (black_image[MARGIN_BOTTOM].is_valid()) {
Size2 sz(rasterizer->texture_get_width(black_image[MARGIN_BOTTOM]),rasterizer->texture_get_height(black_image[MARGIN_BOTTOM]));
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));
} else if (black_margin[MARGIN_BOTTOM]) {
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));
}
rasterizer->canvas_end_rect();
};
void VisualServerRaster::sync() {
//do none
}
void VisualServerRaster::draw() {
//if (changes)
// print_line("changes: "+itos(changes));
changes=0;
shadows_enabled=GLOBAL_DEF("render/shadows_enabled",true);
room_cull_enabled = GLOBAL_DEF("render/room_cull_enabled",true);
light_discard_enabled = GLOBAL_DEF("render/light_discard_enabled",true);
rasterizer->begin_frame();
_draw_viewports();
_draw_cursors_and_margins();
rasterizer->end_frame();
draw_extra_frame=rasterizer->needs_to_draw_next_frame();
}
bool VisualServerRaster::has_changed() const {
return changes>0 || draw_extra_frame;
}
int VisualServerRaster::get_render_info(RenderInfo p_info) {
return rasterizer->get_render_info(p_info);
}
bool VisualServerRaster::has_feature(Features p_feature) const {
return rasterizer->has_feature(p_feature); // lies for now
}
void VisualServerRaster::set_default_clear_color(const Color& p_color) {
clear_color=p_color;
}
void VisualServerRaster::set_boot_image(const Image& p_image, const Color& p_color,bool p_scale) {
if (p_image.empty())
return;
rasterizer->restore_framebuffer();
rasterizer->begin_frame();
int window_w = OS::get_singleton()->get_video_mode(0).width;
int window_h = OS::get_singleton()->get_video_mode(0).height;
ViewportRect vr;
vr.x=0;
vr.y=0;
vr.width=OS::get_singleton()->get_video_mode(0).width;
vr.height=OS::get_singleton()->get_video_mode(0).height;
rasterizer->set_viewport(vr);
rasterizer->clear_viewport(p_color);
rasterizer->canvas_begin();
RID texture = texture_create();
texture_allocate(texture,p_image.get_width(),p_image.get_height(),p_image.get_format(),TEXTURE_FLAG_FILTER);
texture_set_data(texture,p_image);
rasterizer->canvas_begin_rect(Matrix32());
Rect2 imgrect(0,0,p_image.get_width(),p_image.get_height());
Rect2 screenrect;
if (p_scale) {
if (window_w > window_h) {
//scale horizontally
screenrect.size.y = window_h;
screenrect.size.x = imgrect.size.x * window_h / imgrect.size.y;
screenrect.pos.x = (window_w - screenrect.size.x)/2;
} else {
//scale vertically
screenrect.size.x = window_w;
screenrect.size.y = imgrect.size.y * window_w / imgrect.size.x;
screenrect.pos.y = (window_h - screenrect.size.y)/2;
}
} else {
screenrect=imgrect;
screenrect.pos+=((Size2(vr.width,vr.height)-screenrect.size)/2.0).floor();
}
rasterizer->canvas_draw_rect(screenrect,0,imgrect,texture,Color(1,1,1,1));
rasterizer->canvas_end_rect();
rasterizer->end_frame();
rasterizer->flush_frame();
free(texture); // free since it's only one frame that stays there
}
void VisualServerRaster::init() {
rasterizer->init();
shadows_enabled=GLOBAL_DEF("render/shadows_enabled",true);
//default_scenario = scenario_create();
//default_viewport = viewport_create();
for(int i=0;i<4;i++)
black_margin[i]=0;
Image img;
img.create(default_mouse_cursor_xpm);
//img.convert(Image::FORMAT_RGB);
default_cursor_texture = texture_create_from_image(img, 0);
aabb_random_points.resize( GLOBAL_DEF("render/aabb_random_points",16) );
for(int i=0;i<aabb_random_points.size();i++)
aabb_random_points[i]=Vector3(Math::random(0,1),Math::random(0,1),Math::random(0,1));
transformed_aabb_random_points.resize(aabb_random_points.size());
changes=0;
}
void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner,String p_type) {
List<RID> rids;
p_owner->get_owned_list(&rids);
int lost=0;
for(List<RID>::Element *I=rids.front();I;I=I->next()) {
if (OS::get_singleton()->is_stdout_verbose()) {
lost++;
}
free(I->get());
}
if (lost)
print_line("VisualServerRaster: WARNING: Lost "+itos(lost)+" RIDs of type "+p_type);
}
void VisualServerRaster::finish() {
free(default_cursor_texture);
if (test_cube.is_valid())
free(test_cube);
_free_internal_rids();
_clean_up_owner( &room_owner,"Room" );
_clean_up_owner( &portal_owner,"Portal" );
_clean_up_owner( &camera_owner,"Camera" );
_clean_up_owner( &viewport_owner,"Viewport" );
_clean_up_owner( &scenario_owner,"Scenario" );
_clean_up_owner( &instance_owner,"Instance" );
_clean_up_owner( &canvas_owner,"Canvas" );
_clean_up_owner( &canvas_item_owner,"CanvasItem" );
rasterizer->finish();
octree_allocator.clear();
if (instance_dependency_map.size()) {
print_line("Base resources missing amount: "+itos(instance_dependency_map.size()));
}
ERR_FAIL_COND( instance_dependency_map.size() );
}
RID VisualServerRaster::get_test_cube() {
if (test_cube.is_valid())
return test_cube;
test_cube=_make_test_cube();
return test_cube;
}
VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer) {
rasterizer=p_rasterizer;
rasterizer->draw_viewport_func=_render_canvas_item_viewport;
instance_update_list=NULL;
render_pass=0;
clear_color=Color(0.3,0.3,0.3,1.0);
OctreeAllocator::allocator=&octree_allocator;
draw_extra_frame=false;
}
VisualServerRaster::~VisualServerRaster()
{
}
Reference in New Issue View Git Blame Copy Permalink