virtualx-engine/servers/visual/visual_server_viewport.cpp
Juan Linietsky bc26f90581 Type renames:
Matrix32 -> Transform2D
	Matrix3 -> Basis
	AABB -> Rect3
	RawArray -> PoolByteArray
	IntArray -> PoolIntArray
	FloatArray -> PoolFloatArray
	Vector2Array -> PoolVector2Array
	Vector3Array -> PoolVector3Array
	ColorArray -> PoolColorArray
2017-01-11 00:52:51 -03:00

568 lines
16 KiB
C++

#include "visual_server_viewport.h"
#include "visual_server_global.h"
#include "visual_server_canvas.h"
#include "visual_server_scene.h"
#include "globals.h"
void VisualServerViewport::_draw_viewport(Viewport *p_viewport) {
/* Camera should always be BEFORE any other 3D */
#if 0
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;
}
}
#endif
if (p_viewport->clear_mode!=VS::VIEWPORT_CLEAR_NEVER) {
VSG::rasterizer->clear_render_target(clear_color);
if (p_viewport->clear_mode==VS::VIEWPORT_CLEAR_ONLY_NEXT_FRAME) {
p_viewport->clear_mode=VS::VIEWPORT_CLEAR_NEVER;
}
}
if (!p_viewport->disable_3d && p_viewport->camera.is_valid()) {
VSG::scene->render_camera(p_viewport->camera,p_viewport->scenario,p_viewport->size,p_viewport->shadow_atlas);
}
if (!p_viewport->hide_canvas) {
int i=0;
Map<Viewport::CanvasKey,Viewport::CanvasData*> canvas_map;
Rect2 clip_rect(0,0,p_viewport->size.x,p_viewport->size.y);
RasterizerCanvas::Light *lights=NULL;
RasterizerCanvas::Light *lights_with_shadow=NULL;
RasterizerCanvas::Light *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()) {
Transform2D xf = p_viewport->global_transform * E->get().transform;
VisualServerCanvas::Canvas *canvas = static_cast<VisualServerCanvas::Canvas*>(E->get().canvas);
//find lights in canvas
for(Set<RasterizerCanvas::Light*>::Element *F=canvas->lights.front();F;F=F->next()) {
RasterizerCanvas::Light* cl=F->get();
if (cl->enabled && cl->texture.is_valid()) {
//not super efficient..
Size2 tsize(VSG::storage->texture_get_width(cl->texture),VSG::storage->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;
Transform2D 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==VS::CANVAS_LIGHT_MODE_MASK) {
cl->mask_next_ptr=lights_with_mask;
lights_with_mask=cl;
}
light_count++;
}
VSG::canvas_render->light_internal_update(cl->light_internal,cl);
}
}
//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
RasterizerCanvas::LightOccluderInstance * occluders=NULL;
//make list of occluders
for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
VisualServerCanvas::Canvas *canvas = static_cast<VisualServerCanvas::Canvas*>(E->get().canvas);
Transform2D xf = p_viewport->global_transform * E->get().transform;
for(Set<RasterizerCanvas::LightOccluderInstance*>::Element *F=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
RasterizerCanvas::Light *light=lights_with_shadow;
while(light) {
VSG::canvas_render->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;
}
// VSG::canvas_render->reset_canvas();
}
VSG::rasterizer->restore_render_target();
#if 0
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;
}
#endif
for (Map<Viewport::CanvasKey,Viewport::CanvasData*>::Element *E=canvas_map.front();E;E=E->next()) {
VisualServerCanvas::Canvas *canvas = static_cast<VisualServerCanvas::Canvas*>(E->get()->canvas);
// print_line("canvas "+itos(i)+" size: "+itos(I->get()->canvas->child_items.size()));
//print_line("GT "+p_viewport->global_transform+". CT: "+E->get()->transform);
Transform2D xform = p_viewport->global_transform * E->get()->transform;
RasterizerCanvas::Light *canvas_lights=NULL;
RasterizerCanvas::Light *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;
}
VSG::canvas->render_canvas( canvas,xform,canvas_lights,lights_with_mask,clip_rect );
i++;
#if 0
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;
}
#endif
}
#if 0
if (scenario_draw_canvas_bg) {
_draw_viewport_camera(p_viewport,!can_draw_3d);
scenario_draw_canvas_bg=false;
}
#endif
//VSG::canvas_render->canvas_debug_viewport_shadows(lights_with_shadow);
}
}
void VisualServerViewport::draw_viewports() {
//sort viewports
//draw viewports
clear_color=GLOBAL_GET("rendering/viewport/default_clear_color");
active_viewports.sort_custom<ViewportSort>();
for(int i=0;i<active_viewports.size();i++) {
Viewport *vp = active_viewports[i];
if (vp->update_mode==VS::VIEWPORT_UPDATE_DISABLED)
continue;
ERR_CONTINUE( !vp->render_target.is_valid() );
bool visible = vp->viewport_to_screen_rect!=Rect2() || vp->update_mode==VS::VIEWPORT_UPDATE_ALWAYS || vp->update_mode==VS::VIEWPORT_UPDATE_ONCE;
if (!visible)
continue;
VSG::rasterizer->set_current_render_target(vp->render_target);
_draw_viewport(vp);
if (vp->viewport_to_screen_rect!=Rect2()) {
//copy to screen if set as such
VSG::rasterizer->set_current_render_target(RID());
VSG::rasterizer->blit_render_target_to_screen(vp->render_target,vp->viewport_to_screen_rect,vp->viewport_to_screen);
}
if (vp->update_mode==VS::VIEWPORT_UPDATE_ONCE) {
vp->update_mode=VS::VIEWPORT_UPDATE_DISABLED;
}
}
}
RID VisualServerViewport::viewport_create() {
Viewport * viewport = memnew( Viewport );
RID rid = viewport_owner.make_rid(viewport);
viewport->self=rid;
viewport->hide_scenario=false;
viewport->hide_canvas=false;
viewport->render_target=VSG::storage->render_target_create();
viewport->shadow_atlas=VSG::scene_render->shadow_atlas_create();
return rid;
}
void VisualServerViewport::viewport_set_size(RID p_viewport,int p_width,int p_height){
ERR_FAIL_COND(p_width<0 && p_height<0);
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->size=Size2(p_width,p_height);
VSG::storage->render_target_set_size(viewport->render_target,p_width,p_height);
}
void VisualServerViewport::viewport_set_active(RID p_viewport,bool p_active) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
if (p_active) {
ERR_FAIL_COND(active_viewports.find(viewport)!=-1);//already active
active_viewports.push_back(viewport);
} else {
active_viewports.erase(viewport);
}
}
void VisualServerViewport::viewport_set_parent_viewport(RID p_viewport,RID p_parent_viewport) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->parent=p_parent_viewport;
}
void VisualServerViewport::viewport_set_clear_mode(RID p_viewport,VS::ViewportClearMode p_clear_mode) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->clear_mode=p_clear_mode;
}
void VisualServerViewport::viewport_attach_to_screen(RID p_viewport,const Rect2& p_rect,int p_screen){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->viewport_to_screen_rect=p_rect;
viewport->viewport_to_screen=p_screen;
}
void VisualServerViewport::viewport_detach(RID p_viewport){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->viewport_to_screen_rect=Rect2();
viewport->viewport_to_screen=0;
}
void VisualServerViewport::viewport_set_update_mode(RID p_viewport,VS::ViewportUpdateMode p_mode){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->update_mode=p_mode;
}
void VisualServerViewport::viewport_set_vflip(RID p_viewport,bool p_enable){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VSG::storage->render_target_set_flag(viewport->render_target,RasterizerStorage::RENDER_TARGET_VFLIP,p_enable);
}
RID VisualServerViewport::viewport_get_texture(RID p_viewport) const{
const Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND_V(!viewport,RID());
return VSG::storage->render_target_get_texture(viewport->render_target);
}
void VisualServerViewport::viewport_set_hide_scenario(RID p_viewport,bool p_hide){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->hide_scenario=p_hide;
}
void VisualServerViewport::viewport_set_hide_canvas(RID p_viewport,bool p_hide){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->hide_canvas=p_hide;
}
void VisualServerViewport::viewport_set_disable_environment(RID p_viewport,bool p_disable){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->disable_environment=p_disable;
}
void VisualServerViewport::viewport_set_disable_3d(RID p_viewport,bool p_disable){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->disable_3d=p_disable;
VSG::storage->render_target_set_flag(viewport->render_target,RasterizerStorage::RENDER_TARGET_NO_3D,p_disable);
}
void VisualServerViewport::viewport_attach_camera(RID p_viewport,RID p_camera){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->camera=p_camera;
}
void VisualServerViewport::viewport_set_scenario(RID p_viewport,RID p_scenario){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->scenario=p_scenario;
}
void VisualServerViewport::viewport_attach_canvas(RID p_viewport,RID p_canvas){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
VisualServerCanvas::Canvas *canvas = VSG::canvas->canvas_owner.getornull(p_canvas);
ERR_FAIL_COND(!canvas);
canvas->viewports.insert(p_viewport);
viewport->canvas_map[p_canvas]=Viewport::CanvasData();
viewport->canvas_map[p_canvas].layer=0;
viewport->canvas_map[p_canvas].canvas=canvas;
}
void VisualServerViewport::viewport_remove_canvas(RID p_viewport,RID p_canvas){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VisualServerCanvas::Canvas *canvas = VSG::canvas->canvas_owner.getornull(p_canvas);
ERR_FAIL_COND(!canvas);
viewport->canvas_map.erase(p_canvas);
canvas->viewports.erase(p_viewport);
}
void VisualServerViewport::viewport_set_canvas_transform(RID p_viewport,RID p_canvas,const Transform2D& p_offset){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas));
viewport->canvas_map[p_canvas].transform=p_offset;
}
void VisualServerViewport::viewport_set_transparent_background(RID p_viewport,bool p_enabled){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VSG::storage->render_target_set_flag(viewport->render_target,RasterizerStorage::RENDER_TARGET_TRANSPARENT,p_enabled);
}
void VisualServerViewport::viewport_set_global_canvas_transform(RID p_viewport,const Transform2D& p_transform){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->global_transform=p_transform;
}
void VisualServerViewport::viewport_set_canvas_layer(RID p_viewport,RID p_canvas,int p_layer){
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas));
viewport->canvas_map[p_canvas].layer=p_layer;
}
void VisualServerViewport::viewport_set_shadow_atlas_size(RID p_viewport,int p_size) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
viewport->shadow_atlas_size=p_size;
VSG::scene_render->shadow_atlas_set_size( viewport->shadow_atlas, viewport->shadow_atlas_size);
}
void VisualServerViewport::viewport_set_shadow_atlas_quadrant_subdivision(RID p_viewport,int p_quadrant,int p_subdiv) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VSG::scene_render->shadow_atlas_set_quadrant_subdivision( viewport->shadow_atlas, p_quadrant, p_subdiv);
}
void VisualServerViewport::viewport_set_msaa(RID p_viewport,VS::ViewportMSAA p_msaa) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VSG::storage->render_target_set_msaa(viewport->render_target,p_msaa);
}
void VisualServerViewport::viewport_set_hdr(RID p_viewport,bool p_enabled) {
Viewport * viewport = viewport_owner.getornull(p_viewport);
ERR_FAIL_COND(!viewport);
VSG::storage->render_target_set_flag(viewport->render_target,RasterizerStorage::RENDER_TARGET_HDR,p_enabled);
}
bool VisualServerViewport::free(RID p_rid) {
if (viewport_owner.owns(p_rid)) {
Viewport * viewport = viewport_owner.getornull(p_rid);
VSG::storage->free( viewport->render_target );
VSG::scene_render->free( viewport->shadow_atlas );
while(viewport->canvas_map.front()) {
viewport_remove_canvas(p_rid,viewport->canvas_map.front()->key());
}
viewport_set_scenario(p_rid,RID());
active_viewports.erase(viewport);
viewport_owner.free(p_rid);
memdelete(viewport);
return true;
}
return false;
}
VisualServerViewport::VisualServerViewport()
{
}