Everything returning to normal in 3D, still a long way to go

-implemented the scene part of visual server and rasterizer, objects without lighting and material are rendererd only

bin/tests/test_render.cpp

@@ -173,7 +173,10 @@ public:
 // 		vs->camera_set_perspective( camera, 60.0,0.1, 100.0 );
 
 		viewport = vs->viewport_create();
-		vs->viewport_attach_to_screen(viewport,Rect2(Vector2(),OS::get_singleton()->get_window_size()));
+		Size2i screen_size = OS::get_singleton()->get_window_size();
+		vs->viewport_set_size(viewport,screen_size.x,screen_size.y);
+		vs->viewport_attach_to_screen(viewport,Rect2(Vector2(),screen_size));
+		vs->viewport_set_active(viewport,true);
 		vs->viewport_attach_camera( viewport, camera );
 		vs->viewport_set_scenario( viewport, scenario );
 		vs->camera_set_transform(camera, Transform( Matrix3(), Vector3(0,3,30 ) ) );

core/math/math_funcs.h

@@ -175,6 +175,108 @@ public:
 	static double log(double x);
 	static double exp(double x);
 
+
+	static _FORCE_INLINE_ uint32_t halfbits_to_floatbits(uint16_t h)
+	{
+	    uint16_t h_exp, h_sig;
+	    uint32_t f_sgn, f_exp, f_sig;
+
+	    h_exp = (h&0x7c00u);
+	    f_sgn = ((uint32_t)h&0x8000u) << 16;
+	    switch (h_exp) {
+		case 0x0000u: /* 0 or subnormal */
+		    h_sig = (h&0x03ffu);
+		    /* Signed zero */
+		    if (h_sig == 0) {
+			return f_sgn;
+		    }
+		    /* Subnormal */
+		    h_sig <<= 1;
+		    while ((h_sig&0x0400u) == 0) {
+			h_sig <<= 1;
+			h_exp++;
+		    }
+		    f_exp = ((uint32_t)(127 - 15 - h_exp)) << 23;
+		    f_sig = ((uint32_t)(h_sig&0x03ffu)) << 13;
+		    return f_sgn + f_exp + f_sig;
+		case 0x7c00u: /* inf or NaN */
+		    /* All-ones exponent and a copy of the significand */
+		    return f_sgn + 0x7f800000u + (((uint32_t)(h&0x03ffu)) << 13);
+		default: /* normalized */
+		    /* Just need to adjust the exponent and shift */
+		    return f_sgn + (((uint32_t)(h&0x7fffu) + 0x1c000u) << 13);
+	    }
+	}
+
+	static _FORCE_INLINE_ float halfptr_to_float(uint16_t *h) {
+
+		union {
+			uint32_t u32;
+			float f32;
+		} u;
+
+		u.u32=halfbits_to_floatbits(*h);
+		return u.f32;
+	}
+
+	static _FORCE_INLINE_ uint16_t make_half_float(float f) {
+
+	    union {
+	       float fv;
+	       uint32_t ui;
+	    } ci;
+	    ci.fv=f;
+
+	    uint32_t    x = ci.ui;
+	    uint32_t    sign = (unsigned short)(x >> 31);
+	    uint32_t    mantissa;
+	    uint32_t    exp;
+	    uint16_t          hf;
+
+	    // get mantissa
+	    mantissa = x & ((1 << 23) - 1);
+	    // get exponent bits
+	    exp = x & (0xFF << 23);
+	    if (exp >= 0x47800000)
+	    {
+		// check if the original single precision float number is a NaN
+		if (mantissa && (exp == (0xFF << 23)))
+		{
+		    // we have a single precision NaN
+		    mantissa = (1 << 23) - 1;
+		}
+		else
+		{
+		    // 16-bit half-float representation stores number as Inf
+		    mantissa = 0;
+		}
+		hf = (((uint16_t)sign) << 15) | (uint16_t)((0x1F << 10)) |
+		      (uint16_t)(mantissa >> 13);
+	    }
+	    // check if exponent is <= -15
+	    else if (exp <= 0x38000000)
+	    {
+
+		/*// store a denorm half-float value or zero
+		exp = (0x38000000 - exp) >> 23;
+		mantissa >>= (14 + exp);
+
+		hf = (((uint16_t)sign) << 15) | (uint16_t)(mantissa);
+		*/
+		hf=0; //denormals do not work for 3D, convert to zero
+	    }
+	    else
+	    {
+		hf = (((uint16_t)sign) << 15) |
+		      (uint16_t)((exp - 0x38000000) >> 13) |
+		      (uint16_t)(mantissa >> 13);
+	    }
+
+	    return hf;
+	}
+
+
+
 };
 
 

core/rid.h

@@ -181,6 +181,14 @@ public:
 
 	}
 
+
+	_FORCE_INLINE_ T * getptr(const RID& p_rid) {
+
+		return static_cast<T*>(p_rid.get_data());
+
+	}
+
+
 	_FORCE_INLINE_ bool owns(const RID& p_rid) const {
 
 		if (p_rid.get_data()==NULL)

drivers/gles3/rasterizer_canvas_gles3.cpp

@@ -117,6 +117,7 @@ void RasterizerCanvasGLES3::canvas_begin(){
 		glClearColor( storage->frame.clear_request_color.r, storage->frame.clear_request_color.g, storage->frame.clear_request_color.b, storage->frame.clear_request_color.a );
 		glClear(GL_COLOR_BUFFER_BIT);
 		storage->frame.clear_request=false;
+		print_line("canvas clear?");
 
 	}
 

drivers/gles3/rasterizer_gles3.cpp

@@ -15,7 +15,7 @@ RasterizerCanvas *RasterizerGLES3::get_canvas() {
 
 RasterizerScene *RasterizerGLES3::get_scene() {
 
-	return NULL;
+	return scene;
 }
 
 
@@ -111,6 +111,7 @@ void RasterizerGLES3::initialize() {
 */
 	storage->initialize();
 	canvas->initialize();
+	scene->initialize();
 }
 
 void RasterizerGLES3::begin_frame(){
@@ -124,6 +125,7 @@ void RasterizerGLES3::begin_frame(){
 
 	storage->update_dirty_shaders();
 	storage->update_dirty_materials();
+
 }
 
 void RasterizerGLES3::set_current_render_target(RID p_render_target){
@@ -131,6 +133,7 @@ void RasterizerGLES3::set_current_render_target(RID p_render_target){
 	if (!p_render_target.is_valid() && storage->frame.current_rt && storage->frame.clear_request) {
 		//handle pending clear request, if the framebuffer was not cleared
 		glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->front.fbo);
+		print_line("unbind clear of: "+storage->frame.clear_request_color);
 		glClearColor(
 			storage->frame.clear_request_color.r,
 			storage->frame.clear_request_color.g,
@@ -265,8 +268,12 @@ RasterizerGLES3::RasterizerGLES3()
 
 	storage = memnew( RasterizerStorageGLES3 );
 	canvas = memnew( RasterizerCanvasGLES3 );
+	scene = memnew( RasterizerSceneGLES3 );
 	canvas->storage=storage;
 	storage->canvas=canvas;
+	scene->storage=storage;
+	storage->scene=scene;
+
 
 
 }

drivers/gles3/rasterizer_gles3.h

@@ -4,6 +4,7 @@
 #include "servers/visual/rasterizer.h"
 #include "rasterizer_storage_gles3.h"
 #include "rasterizer_canvas_gles3.h"
+#include "rasterizer_scene_gles3.h"
 
 
 class RasterizerGLES3 : public Rasterizer {
@@ -12,6 +13,8 @@ class RasterizerGLES3 : public Rasterizer {
 
 	RasterizerStorageGLES3 *storage;
 	RasterizerCanvasGLES3 *canvas;
+	RasterizerSceneGLES3 *scene;
+
 public:
 
 	virtual RasterizerStorage *get_storage();

drivers/gles3/rasterizer_scene_gles3.cpp

@@ -0,0 +1,808 @@
+#include "rasterizer_scene_gles3.h"
+#include "globals.h"
+static _FORCE_INLINE_ void store_matrix32(const Matrix32& p_mtx, float* p_array) {
+
+	p_array[ 0]=p_mtx.elements[0][0];
+	p_array[ 1]=p_mtx.elements[0][1];
+	p_array[ 2]=0;
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.elements[1][0];
+	p_array[ 5]=p_mtx.elements[1][1];
+	p_array[ 6]=0;
+	p_array[ 7]=0;
+	p_array[ 8]=0;
+	p_array[ 9]=0;
+	p_array[10]=1;
+	p_array[11]=0;
+	p_array[12]=p_mtx.elements[2][0];
+	p_array[13]=p_mtx.elements[2][1];
+	p_array[14]=0;
+	p_array[15]=1;
+}
+
+
+static _FORCE_INLINE_ void store_transform(const Transform& p_mtx, float* p_array) {
+	p_array[ 0]=p_mtx.basis.elements[0][0];
+	p_array[ 1]=p_mtx.basis.elements[1][0];
+	p_array[ 2]=p_mtx.basis.elements[2][0];
+	p_array[ 3]=0;
+	p_array[ 4]=p_mtx.basis.elements[0][1];
+	p_array[ 5]=p_mtx.basis.elements[1][1];
+	p_array[ 6]=p_mtx.basis.elements[2][1];
+	p_array[ 7]=0;
+	p_array[ 8]=p_mtx.basis.elements[0][2];
+	p_array[ 9]=p_mtx.basis.elements[1][2];
+	p_array[10]=p_mtx.basis.elements[2][2];
+	p_array[11]=0;
+	p_array[12]=p_mtx.origin.x;
+	p_array[13]=p_mtx.origin.y;
+	p_array[14]=p_mtx.origin.z;
+	p_array[15]=1;
+}
+
+static _FORCE_INLINE_ void store_camera(const CameraMatrix& p_mtx, float* p_array) {
+
+	for (int i=0;i<4;i++) {
+		for (int j=0;j<4;j++) {
+
+			p_array[i*4+j]=p_mtx.matrix[i][j];
+		}
+	}
+}
+
+
+
+RID RasterizerSceneGLES3::light_instance_create(RID p_light) {
+
+
+	return RID();
+}
+
+void RasterizerSceneGLES3::light_instance_set_transform(RID p_light_instance,const Transform& p_transform){
+
+
+}
+
+
+bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass) {
+
+	if (p_material->shader->spatial.cull_mode==RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_DISABLED) {
+		glDisable(GL_CULL_FACE);
+	} else {
+		glEnable(GL_CULL_FACE);
+	}
+
+	//glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
+
+	/*
+	if (p_material->flags[VS::MATERIAL_FLAG_WIREFRAME])
+		glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
+	else
+		glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
+	*/
+
+	//if (p_material->line_width)
+	//	glLineWidth(p_material->line_width);
+
+
+	//blend mode
+	if (state.current_blend_mode!=p_material->shader->spatial.blend_mode) {
+
+		switch(p_material->shader->spatial.blend_mode) {
+
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX: {
+				glBlendEquation(GL_FUNC_ADD);
+				if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+				} else {
+					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				}
+
+			 } break;
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD: {
+
+				glBlendEquation(GL_FUNC_ADD);
+				glBlendFunc(p_alpha_pass?GL_SRC_ALPHA:GL_ONE,GL_ONE);
+
+			 } break;
+			 case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_SUB: {
+
+				glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+				glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+			 } break;
+			case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MUL: {
+				glBlendEquation(GL_FUNC_ADD);
+				if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+				} else {
+					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+				}
+
+			} break;
+		}
+
+		state.current_blend_mode=p_material->shader->spatial.blend_mode;
+
+	}
+
+	//material parameters
+
+	state.scene_shader.set_custom_shader(p_material->shader->custom_code_id);
+	bool rebind = state.scene_shader.bind();
+
+
+	if (p_material->ubo_id) {
+		glBindBufferBase(GL_UNIFORM_BUFFER,1,p_material->ubo_id);
+	}
+
+
+
+	int tc = p_material->textures.size();
+	RID* textures = p_material->textures.ptr();
+
+	for(int i=0;i<tc;i++) {
+
+		glActiveTexture(GL_TEXTURE0+i);
+
+		RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
+		if (!t) {
+			//check hints
+			glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+			continue;
+		}
+
+		glBindTexture(t->target,t->tex_id);
+	}
+
+
+	return rebind;
+
+}
+
+
+void RasterizerSceneGLES3::_setup_geometry(RenderList::Element *e) {
+
+	switch(e->instance->base_type) {
+
+		case VS::INSTANCE_MESH: {
+
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+			glBindVertexArray(s->array_id); // everything is so easy nowadays
+		} break;
+	}
+
+}
+
+static const GLenum gl_primitive[]={
+	GL_POINTS,
+	GL_LINES,
+	GL_LINE_STRIP,
+	GL_LINE_LOOP,
+	GL_TRIANGLES,
+	GL_TRIANGLE_STRIP,
+	GL_TRIANGLE_FAN
+};
+
+
+
+void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
+
+	switch(e->instance->base_type) {
+
+		case VS::INSTANCE_MESH: {
+
+			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+
+			if (s->index_array_len>0) {
+
+				glDrawElements(gl_primitive[s->primitive],s->index_array_len, (s->array_len>=(1<<16))?GL_UNSIGNED_INT:GL_UNSIGNED_SHORT,0);
+
+			} else {
+
+				glDrawArrays(gl_primitive[s->primitive],0,s->array_len);
+
+			}
+
+		} break;
+	}
+
+}
+
+void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements,int p_element_count,const Transform& p_view_transform,const CameraMatrix& p_projection,bool p_reverse_cull,bool p_alpha_pass) {
+
+	if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
+		//p_reverse_cull=!p_reverse_cull;
+		glFrontFace(GL_CCW);
+	} else {
+		glFrontFace(GL_CW);
+	}
+
+	glBindBufferBase(GL_UNIFORM_BUFFER,0,state.scene_ubo); //bind globals ubo
+
+	state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,false);
+
+	state.current_blend_mode=-1;
+
+	glDisable(GL_BLEND);
+
+	RasterizerStorageGLES3::Material* prev_material=NULL;
+	RasterizerStorageGLES3::Geometry* prev_geometry=NULL;
+	VS::InstanceType prev_base_type = VS::INSTANCE_MAX;
+
+	for (int i=0;i<p_element_count;i++) {
+
+		RenderList::Element *e = p_elements[i];
+		RasterizerStorageGLES3::Material* material= e->material;
+
+		bool rebind=i==0;
+
+		if (material!=prev_material || rebind) {
+
+			rebind = _setup_material(material,p_alpha_pass);
+//			_rinfo.mat_change_count++;
+		}
+
+
+		if (prev_base_type != e->instance->base_type || prev_geometry!=e->geometry) {
+
+			_setup_geometry(e);
+		}
+
+//		_set_cull(e->mirror,p_reverse_cull);
+
+		state.scene_shader.set_uniform(SceneShaderGLES3::NORMAL_MULT, e->instance->mirror?-1.0:1.0);
+		state.scene_shader.set_uniform(SceneShaderGLES3::WORLD_TRANSFORM, e->instance->transform);
+
+
+//		_render(e->geometry, material, skeleton,e->owner,e->instance->transform);
+
+		_render_geometry(e);
+
+		prev_material=material;
+		prev_base_type=e->instance->base_type;
+		prev_geometry=e->geometry;
+	}
+
+	//print_line("shaderchanges: "+itos(p_alpha_pass)+": "+itos(_rinfo.shader_change_count));
+
+
+	glFrontFace(GL_CW);
+	glBindVertexArray(0);
+
+}
+
+void RasterizerSceneGLES3::_add_geometry(  RasterizerStorageGLES3::Geometry* p_geometry,  InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material) {
+
+	RasterizerStorageGLES3::Material *m=NULL;
+	RID m_src=p_instance->material_override.is_valid() ? p_instance->material_override :(p_material>=0?p_instance->materials[p_material]:p_geometry->material);
+
+/*
+#ifdef DEBUG_ENABLED
+	if (current_debug==VS::SCENARIO_DEBUG_OVERDRAW) {
+		m_src=overdraw_material;
+	}
+
+#endif
+*/
+	if (m_src.is_valid()) {
+		m=storage->material_owner.getornull( m_src );
+		if (!m->shader) {
+			m=NULL;
+		}
+	}
+
+	if (!m) {
+		m=storage->material_owner.getptr( default_material );
+	}
+
+	ERR_FAIL_COND(!m);
+
+
+
+	//bool has_base_alpha=(m->shader_cache && m->shader_cache->has_alpha);
+	//bool has_blend_alpha=m->blend_mode!=VS::MATERIAL_BLEND_MODE_MIX || m->flags[VS::MATERIAL_FLAG_ONTOP];
+	bool has_alpha = false; //has_base_alpha || has_blend_alpha;
+
+#if 0
+	if (shadow) {
+
+		if (has_blend_alpha || (has_base_alpha && m->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA))
+			return; //bye
+
+		if (!m->shader_cache || (!m->shader_cache->writes_vertex && !m->shader_cache->uses_discard && m->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA)) {
+			//shader does not use discard and does not write a vertex position, use generic material
+			if (p_instance->cast_shadows == VS::SHADOW_CASTING_SETTING_DOUBLE_SIDED)
+				m = shadow_mat_double_sided_ptr;
+			else
+				m = shadow_mat_ptr;
+			if (m->last_pass!=frame) {
+
+				if (m->shader.is_valid()) {
+
+					m->shader_cache=shader_owner.get(m->shader);
+					if (m->shader_cache) {
+
+
+						if (!m->shader_cache->valid)
+							m->shader_cache=NULL;
+					} else {
+						m->shader=RID();
+					}
+
+				} else {
+					m->shader_cache=NULL;
+				}
+
+				m->last_pass=frame;
+			}
+		}
+
+		render_list = &opaque_render_list;
+	/* notyet
+		if (!m->shader_cache || m->shader_cache->can_zpass)
+			render_list = &alpha_render_list;
+		} else {
+			render_list = &opaque_render_list;
+		}*/
+
+	} else {
+		if (has_alpha) {
+			render_list = &alpha_render_list;
+		} else {
+			render_list = &opaque_render_list;
+
+		}
+	}
+#endif
+
+	RenderList::Element *e = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
+
+	if (!e)
+		return;
+
+	e->geometry=p_geometry;
+	e->material=m;
+	e->instance=p_instance;
+	e->owner=p_owner;
+	e->additive=false;
+	e->additive_ptr=&e->additive;
+	e->sort_key=0;
+
+	if (e->geometry->last_pass!=render_pass) {
+		e->geometry->last_pass=render_pass;
+		e->geometry->index=current_geometry_index++;
+	}
+
+	e->sort_key|=uint64_t(e->instance->base_type)<<RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
+	e->sort_key|=uint64_t(e->instance->base_type)<<RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
+
+	if (e->material->last_pass!=render_pass) {
+		e->material->last_pass=render_pass;
+		e->material->index=current_material_index++;
+	}
+
+	e->sort_key|=uint64_t(e->material->index)<<RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
+
+	e->sort_key|=uint64_t(e->instance->depth_layer)<<RenderList::SORT_KEY_DEPTH_LAYER_SHIFT;
+
+	//if (e->geometry->type==RasterizerStorageGLES3::Geometry::GEOMETRY_MULTISURFACE)
+	//	e->sort_flags|=RenderList::SORT_FLAG_INSTANCING;
+
+	bool mirror = e->instance->mirror;
+
+//	if (m->flags[VS::MATERIAL_FLAG_INVERT_FACES])
+//		e->mirror=!e->mirror;
+
+	if (mirror) {
+		e->sort_key|=RenderList::SORT_KEY_MIRROR_FLAG;
+	}
+
+	//e->light_type=0xFF; // no lights!
+	e->sort_key|=uint64_t(0xF)<<RenderList::SORT_KEY_LIGHT_TYPE_SHIFT; //light type 0xF is no light?
+	e->sort_key|=uint64_t(0xFFFF)<<RenderList::SORT_KEY_LIGHT_INDEX_SHIFT;
+/* prepass
+	if (!shadow && !has_blend_alpha && has_alpha && m->depth_draw_mode==VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA) {
+
+		//if nothing exists, add this element as opaque too
+		RenderList::Element *oe = opaque_render_list.add_element();
+
+		if (!oe)
+			return;
+
+		memcpy(oe,e,sizeof(RenderList::Element));
+		oe->additive_ptr=&oe->additive;
+	}
+*/
+
+#if 0
+	if (shadow || m->flags[VS::MATERIAL_FLAG_UNSHADED] || current_debug==VS::SCENARIO_DEBUG_SHADELESS) {
+
+		e->light_type=0x7F; //unshaded is zero
+	} else {
+
+		bool duplicate=false;
+
+
+		for(int i=0;i<directional_light_count;i++) {
+			uint16_t sort_key = directional_lights[i]->sort_key;
+			uint8_t light_type = VS::LIGHT_DIRECTIONAL;
+			if (directional_lights[i]->base->shadow_enabled) {
+				light_type|=0x8;
+				if (directional_lights[i]->base->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS)
+					light_type|=0x10;
+				else if (directional_lights[i]->base->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS)
+					light_type|=0x30;
+
+			}
+
+			RenderList::Element *ec;
+			if (duplicate) {
+
+				ec = render_list->add_element();
+				memcpy(ec,e,sizeof(RenderList::Element));
+			} else {
+
+				ec=e;
+				duplicate=true;
+			}
+
+			ec->light_type=light_type;
+			ec->light=sort_key;
+			ec->additive_ptr=&e->additive;
+
+		}
+
+
+		const RID *liptr = p_instance->light_instances.ptr();
+		int ilc=p_instance->light_instances.size();
+
+
+
+		for(int i=0;i<ilc;i++) {
+
+			LightInstance *li=light_instance_owner.get( liptr[i] );
+			if (!li || li->last_pass!=scene_pass) //lit by light not in visible scene
+				continue;
+			uint8_t light_type=li->base->type|0x40; //penalty to ensure directionals always go first
+			if (li->base->shadow_enabled) {
+				light_type|=0x8;
+			}
+			uint16_t sort_key =li->sort_key;
+
+			RenderList::Element *ec;
+			if (duplicate) {
+
+				ec = render_list->add_element();
+				memcpy(ec,e,sizeof(RenderList::Element));
+			} else {
+
+				duplicate=true;
+				ec=e;
+			}
+
+			ec->light_type=light_type;
+			ec->light=sort_key;
+			ec->additive_ptr=&e->additive;
+
+		}
+
+
+
+	}
+
+#endif
+}
+
+void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,CameraMatrix& p_cam_projection,bool p_cam_ortogonal,InstanceBase** p_cull_result,int p_cull_count,RID* p_light_cull_result,int p_light_cull_count,RID* p_directional_lights,int p_directional_light_count,RID p_environment){
+
+
+	//fill up ubo
+
+	store_camera(p_cam_projection,state.ubo_data.projection_matrix);
+	store_transform(p_cam_transform,state.ubo_data.camera_matrix);
+	store_transform(p_cam_transform.affine_inverse(),state.ubo_data.camera_inverse_matrix);
+	for(int i=0;i<4;i++) {
+		state.ubo_data.time[i]=storage->frame.time[i];
+	}
+
+
+	glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
+	glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(State::SceneDataUBO), &state.ubo_data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+
+	render_list.clear();
+
+	render_pass++;
+	current_material_index=0;
+
+	//fill list
+
+	for(int i=0;i<p_cull_count;i++) {
+
+		InstanceBase *inst = p_cull_result[i];
+		switch(inst->base_type) {
+
+			case VS::INSTANCE_MESH: {
+
+				RasterizerStorageGLES3::Mesh *mesh = storage->mesh_owner.getptr(inst->base);
+				ERR_CONTINUE(!mesh);
+
+				int ssize = mesh->surfaces.size();
+
+				for (int i=0;i<ssize;i++) {
+
+					int mat_idx = inst->materials[i].is_valid() ? i : -1;
+					RasterizerStorageGLES3::Surface *s = mesh->surfaces[i];
+					_add_geometry(s,inst,NULL,mat_idx);
+				}
+
+				//mesh->last_pass=frame;
+
+			} break;
+			case VS::INSTANCE_MULTIMESH: {
+
+			} break;
+			case VS::INSTANCE_IMMEDIATE: {
+
+			} break;
+
+		}
+	}
+
+	//
+
+
+	glEnable(GL_BLEND);
+	glDepthMask(GL_TRUE);
+	glEnable(GL_DEPTH_TEST);
+	glDisable(GL_SCISSOR_TEST);
+	glClearDepth(1.0);
+	glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->front.fbo);
+
+
+	if (true) {
+
+		if (storage->frame.clear_request) {
+
+			glClearColor( storage->frame.clear_request_color.r, storage->frame.clear_request_color.g, storage->frame.clear_request_color.b, storage->frame.clear_request_color.a );
+			glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+			storage->frame.clear_request=false;
+
+		}
+	}
+
+	state.current_depth_test=true;
+	state.current_depth_mask=true;
+	state.texscreen_copied=false;
+
+	glBlendEquation(GL_FUNC_ADD);
+
+	if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	} else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+
+	glDisable(GL_BLEND);
+	//current_blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
+
+
+	render_list.sort_by_key(false);
+
+	//_render_list_forward(&opaque_render_list,camera_transform,camera_transform_inverse,camera_projection,false,fragment_lighting);
+/*
+	if (draw_tex_background) {
+
+		//most 3D vendors recommend drawing a texture bg or skybox here,
+		//after opaque geometry has been drawn
+		//so the zbuffer can get rid of most pixels
+		_draw_tex_bg();
+	}
+*/
+	if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	} else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+
+//	glDisable(GL_BLEND);
+//	current_blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
+//	state.scene_shader.set_conditional(SceneShaderGLES3::USE_GLOW,false);
+//	if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
+//		glColorMask(1,1,1,0); //don't touch alpha
+//	}
+
+
+	_render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,false,false);
+
+	//_render_list_forward(&alpha_render_list,camera_transform,camera_transform_inverse,camera_projection,false,fragment_lighting,true);
+	//glColorMask(1,1,1,1);
+
+//	state.scene_shader.set_conditional( SceneShaderGLES3::USE_FOG,false);
+
+	glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
+#if 0
+	if (use_fb) {
+
+
+
+		for(int i=0;i<VS::ARRAY_MAX;i++) {
+			glDisableVertexAttribArray(i);
+		}
+		glBindBuffer(GL_ARRAY_BUFFER,0);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+		glDisable(GL_BLEND);
+		glDisable(GL_DEPTH_TEST);
+		glDisable(GL_CULL_FACE);
+		glDisable(GL_SCISSOR_TEST);
+		glDepthMask(false);
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR]) {
+
+			int hdr_tm = current_env->fx_param[VS::ENV_FX_PARAM_HDR_TONEMAPPER];
+			switch(hdr_tm) {
+				case VS::ENV_FX_HDR_TONE_MAPPER_LINEAR: {
+
+
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_LOG: {
+					copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,true);
+
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT: {
+					copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+				} break;
+				case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT_AUTOWHITE: {
+
+					copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+					copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,true);
+				} break;
+			}
+
+
+			_process_hdr();
+		}
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
+			_process_glow_bloom();
+			int glow_transfer_mode=current_env->fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_BLEND_MODE];
+			if (glow_transfer_mode==1)
+				copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SCREEN,true);
+			if (glow_transfer_mode==2)
+				copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SOFTLIGHT,true);
+		}
+
+		glBindFramebuffer(GL_FRAMEBUFFER, current_rt?current_rt->fbo:base_framebuffer);
+
+		Size2 size;
+		if (current_rt) {
+			glBindFramebuffer(GL_FRAMEBUFFER, current_rt->fbo);
+			glViewport( 0,0,viewport.width,viewport.height);
+			size=Size2(viewport.width,viewport.height);
+		} else {
+			glBindFramebuffer(GL_FRAMEBUFFER, base_framebuffer);
+			glViewport( viewport.x, window_size.height-(viewport.height+viewport.y), viewport.width,viewport.height );
+			size=Size2(viewport.width,viewport.height);
+		}
+
+		//time to copy!!!
+		copy_shader.set_conditional(CopyShaderGLES2::USE_BCS,current_env && current_env->fx_enabled[VS::ENV_FX_BCS]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_SRGB,current_env && current_env->fx_enabled[VS::ENV_FX_SRGB]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW,current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_HDR,current_env && current_env->fx_enabled[VS::ENV_FX_HDR]);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_NO_ALPHA,true);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_FXAA,current_env && current_env->fx_enabled[VS::ENV_FX_FXAA]);
+
+		copy_shader.bind();
+		//copy_shader.set_uniform(CopyShaderGLES2::SOURCE,0);
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
+
+			glActiveTexture(GL_TEXTURE1);
+			glBindTexture(GL_TEXTURE_2D, framebuffer.blur[0].color );
+			glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::GLOW_SOURCE),1);
+
+		}
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR]) {
+
+			glActiveTexture(GL_TEXTURE2);
+			glBindTexture(GL_TEXTURE_2D, current_vd->lum_color );
+			glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::HDR_SOURCE),2);
+			copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_EXPOSURE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]));
+			copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_WHITE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_WHITE]));
+
+		}
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_FXAA])
+			copy_shader.set_uniform(CopyShaderGLES2::PIXEL_SIZE,Size2(1.0/size.x,1.0/size.y));
+
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_BCS]) {
+
+			Vector3 bcs;
+			bcs.x=current_env->fx_param[VS::ENV_FX_PARAM_BCS_BRIGHTNESS];
+			bcs.y=current_env->fx_param[VS::ENV_FX_PARAM_BCS_CONTRAST];
+			bcs.z=current_env->fx_param[VS::ENV_FX_PARAM_BCS_SATURATION];
+			copy_shader.set_uniform(CopyShaderGLES2::BCS,bcs);
+		}
+
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, framebuffer.color );
+		glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::SOURCE),0);
+
+		_copy_screen_quad();
+
+		copy_shader.set_conditional(CopyShaderGLES2::USE_BCS,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_SRGB,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_HDR,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_NO_ALPHA,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_FXAA,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SCREEN,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SOFTLIGHT,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,false);
+		copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,false);
+
+		state.scene_shader.set_conditional(SceneShaderGLES3::USE_8BIT_HDR,false);
+
+
+		if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR] && GLOBAL_DEF("rasterizer/debug_hdr",false)) {
+			_debug_luminances();
+		}
+	}
+
+	current_env=NULL;
+	current_debug=VS::SCENARIO_DEBUG_DISABLED;
+	if (GLOBAL_DEF("rasterizer/debug_shadow_maps",false)) {
+		_debug_shadows();
+	}
+//	_debug_luminances();
+//	_debug_samplers();
+
+	if (using_canvas_bg) {
+		using_canvas_bg=false;
+		glColorMask(1,1,1,1); //don't touch alpha
+	}
+#endif
+}
+
+bool RasterizerSceneGLES3::free(RID p_rid) {
+
+	return false;
+
+}
+
+void RasterizerSceneGLES3::initialize() {
+
+	state.scene_shader.init();
+
+	default_shader = storage->shader_create(VS::SHADER_SPATIAL);
+	default_material = storage->material_create();
+	storage->material_set_shader(default_material,default_shader);
+
+	glGenBuffers(1, &state.scene_ubo);
+	glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(State::SceneDataUBO), &state.scene_ubo, GL_DYNAMIC_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+
+	render_list.max_elements=GLOBAL_DEF("rendering/gles3/max_renderable_elements",(int)RenderList::DEFAULT_MAX_ELEMENTS);
+	if (render_list.max_elements>1000000)
+		render_list.max_elements=1000000;
+	if (render_list.max_elements<1024)
+		render_list.max_elements=1024;
+
+	render_list.init();
+}
+
+void RasterizerSceneGLES3::finalize(){
+
+
+}
+
+
+RasterizerSceneGLES3::RasterizerSceneGLES3()
+{
+
+}

drivers/gles3/rasterizer_scene_gles3.h

@@ -0,0 +1,178 @@
+#ifndef RASTERIZERSCENEGLES3_H
+#define RASTERIZERSCENEGLES3_H
+
+#include "rasterizer_storage_gles3.h"
+#include "drivers/gles3/shaders/scene.glsl.h"
+
+class RasterizerSceneGLES3 : public RasterizerScene {
+public:
+
+	uint64_t render_pass;
+	uint32_t current_material_index;
+	uint32_t current_geometry_index;
+
+	RID default_material;
+	RID default_shader;
+
+	RasterizerStorageGLES3 *storage;
+
+
+
+	struct State {
+
+		bool current_depth_test;
+		bool current_depth_mask;
+		bool texscreen_copied;
+		int current_blend_mode;
+
+		SceneShaderGLES3 scene_shader;
+
+
+		struct SceneDataUBO {
+
+			float projection_matrix[16];
+			float camera_inverse_matrix[16];
+			float camera_matrix[16];
+			float time[4];
+			float ambient_light[4];
+
+		} ubo_data;
+
+		GLuint scene_ubo;
+
+
+
+	} state;
+
+	struct RenderList {
+
+		enum {
+			DEFAULT_MAX_ELEMENTS=65536,
+			MAX_LIGHTS=4,
+			SORT_FLAG_SKELETON=1,
+			SORT_FLAG_INSTANCING=2,
+
+			SORT_KEY_DEPTH_LAYER_SHIFT=58,
+			SORT_KEY_LIGHT_TYPE_SHIFT=54, //type is most important
+			SORT_KEY_LIGHT_INDEX_SHIFT=38, //type is most important
+			SORT_KEY_MATERIAL_INDEX_SHIFT=22,
+			SORT_KEY_GEOMETRY_INDEX_SHIFT=6,
+			SORT_KEY_GEOMETRY_TYPE_SHIFT=2,
+			SORT_KEY_SKELETON_FLAG=2,
+			SORT_KEY_MIRROR_FLAG=1
+
+		};
+
+		int max_elements;
+
+		struct Element {
+
+			RasterizerScene::InstanceBase *instance;
+			RasterizerStorageGLES3::Geometry *geometry;
+			RasterizerStorageGLES3::Material *material;
+			RasterizerStorageGLES3::GeometryOwner *owner;
+			uint64_t sort_key;
+			bool *additive_ptr;
+			bool additive;
+
+		};
+
+
+		Element *_elements;
+		Element **elements;
+
+		int element_count;
+		int alpha_element_count;
+
+		void clear() {
+
+			element_count=0;
+			alpha_element_count=0;
+		}
+
+		//should eventually be replaced by radix
+
+		struct SortByKey {
+
+			_FORCE_INLINE_ bool operator()(const Element* A,  const Element* B ) const {
+				return A->sort_key < B->sort_key;
+			}
+		};
+
+		void sort_by_key(bool p_alpha) {
+
+			SortArray<Element*,SortByKey> sorter;
+			if (p_alpha) {
+				sorter.sort(&elements[max_elements-alpha_element_count-1],alpha_element_count);
+			} else {
+				sorter.sort(elements,element_count);
+			}
+		}
+
+
+		_FORCE_INLINE_ Element* add_element() {
+
+			if (element_count+alpha_element_count>=max_elements)
+				return NULL;
+			elements[element_count]=&_elements[element_count];
+			return elements[element_count++];
+		}
+
+		_FORCE_INLINE_ Element* add_alpha_element() {
+
+			if (element_count+alpha_element_count>=max_elements)
+				return NULL;
+			int idx = max_elements-alpha_element_count-1;
+			elements[idx]=&_elements[idx];
+			alpha_element_count++;
+			return elements[idx];
+		}
+
+		void init() {
+
+			element_count = 0;
+			alpha_element_count =0;
+			elements=memnew_arr(Element*,max_elements);
+			_elements=memnew_arr(Element,max_elements);
+			for (int i=0;i<max_elements;i++)
+				elements[i]=&_elements[i]; // assign elements
+
+		}
+
+		RenderList() {
+
+			max_elements=DEFAULT_MAX_ELEMENTS;
+		}
+
+		~RenderList() {
+			memdelete_arr(elements);
+			memdelete_arr(_elements);
+		}
+	};
+
+
+
+	RenderList render_list;
+
+	_FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass);
+	_FORCE_INLINE_ void _setup_geometry(RenderList::Element *e);
+	_FORCE_INLINE_ void _render_geometry(RenderList::Element *e);
+
+
+	void _render_list(RenderList::Element **p_elements, int p_element_count, const Transform& p_view_transform, const CameraMatrix& p_projection, bool p_reverse_cull, bool p_alpha_pass);
+
+	virtual RID light_instance_create(RID p_light);
+	virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform);
+
+	_FORCE_INLINE_ void _add_geometry(  RasterizerStorageGLES3::Geometry* p_geometry,  InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material);
+
+	virtual void render_scene(const Transform& p_cam_transform,CameraMatrix& p_cam_projection,bool p_cam_ortogonal,InstanceBase** p_cull_result,int p_cull_count,RID* p_light_cull_result,int p_light_cull_count,RID* p_directional_lights,int p_directional_light_count,RID p_environment);
+
+	virtual bool free(RID p_rid);
+
+	void initialize();
+	void finalize();
+	RasterizerSceneGLES3();
+};
+
+#endif // RASTERIZERSCENEGLES3_H

drivers/gles3/rasterizer_storage_gles3.cpp

@@ -1,5 +1,6 @@
 #include "rasterizer_storage_gles3.h"
 #include "rasterizer_canvas_gles3.h"
+#include "rasterizer_scene_gles3.h"
 #include "globals.h"
 
 /* TEXTURE API */
@@ -1039,7 +1040,7 @@ void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode)
 
 	ShaderGLES3* shaders[VS::SHADER_MAX]={
 		&canvas->state.canvas_shader,
-		&canvas->state.canvas_shader,
+		&scene->state.scene_shader,
 		&canvas->state.canvas_shader,
 
 	};
@@ -1108,6 +1109,37 @@ void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const {
 			actions->uniforms=&p_shader->uniforms;
 
 		} break;
+
+		case VS::SHADER_SPATIAL: {
+
+			p_shader->spatial.blend_mode=Shader::Spatial::BLEND_MODE_MIX;
+			p_shader->spatial.depth_draw_mode=Shader::Spatial::DEPTH_DRAW_OPAQUE;
+			p_shader->spatial.cull_mode=Shader::Spatial::CULL_MODE_BACK;
+			p_shader->spatial.uses_alpha=false;
+			p_shader->spatial.unshaded=false;
+			p_shader->spatial.ontop=false;
+
+			shaders.actions_scene.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_ADD);
+			shaders.actions_scene.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MIX);
+			shaders.actions_scene.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_SUB);
+			shaders.actions_scene.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->spatial.blend_mode,Shader::Spatial::BLEND_MODE_MUL);
+
+			shaders.actions_scene.render_mode_values["depth_draw_opaque"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_OPAQUE);
+			shaders.actions_scene.render_mode_values["depth_draw_always"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALWAYS);
+			shaders.actions_scene.render_mode_values["depth_draw_never"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_NEVER);
+			shaders.actions_scene.render_mode_values["depth_draw_alpha_prepass"]=Pair<int*,int>(&p_shader->spatial.depth_draw_mode,Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS);
+
+			shaders.actions_scene.render_mode_values["cull_front"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_FRONT);
+			shaders.actions_scene.render_mode_values["cull_back"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_BACK);
+			shaders.actions_scene.render_mode_values["cull_disable"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_DISABLED);
+
+			shaders.actions_canvas.render_mode_flags["unshaded"]=&p_shader->spatial.unshaded;
+			shaders.actions_canvas.render_mode_flags["ontop"]=&p_shader->spatial.ontop;
+
+			shaders.actions_canvas.usage_flag_pointers["ALPHA"]=&p_shader->spatial.uses_alpha;
+
+		}
+
 	}
 
 
@@ -1905,97 +1937,685 @@ void RasterizerStorageGLES3::update_dirty_materials() {
 
 RID RasterizerStorageGLES3::mesh_create(){
 
-	return RID();
+	Mesh * mesh = memnew( Mesh );
+
+	return mesh_owner.make_rid(mesh);
 }
 
-void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const Vector<DVector<uint8_t> >& p_blend_shapes){
+
+void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes,const Vector<AABB>& p_bone_aabbs){
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX));
+
+	//must have index and bones, both.
+	{
+		uint32_t bones_weight = VS::ARRAY_FORMAT_BONES|VS::ARRAY_FORMAT_WEIGHTS;
+		ERR_EXPLAIN("Array must have both bones and weights in format or none.");
+		ERR_FAIL_COND( (p_format&bones_weight) && (p_format&bones_weight)!=bones_weight );
+	}
 
 
+	bool has_morph = p_blend_shapes.size();
+
+	Surface::Attrib attribs[VS::ARRAY_MAX],morph_attribs[VS::ARRAY_MAX];
+
+	int stride=0;
+	int morph_stride=0;
+
+	for(int i=0;i<VS::ARRAY_MAX;i++) {
+
+		if (! (p_format&(1<<i) ) ) {
+			attribs[i].enabled=false;
+			morph_attribs[i].enabled=false;
+			continue;
+		}
+
+		attribs[i].enabled=true;
+		attribs[i].offset=stride;
+		attribs[i].index=i;
+
+		if (has_morph) {
+			morph_attribs[i].enabled=true;
+			morph_attribs[i].offset=morph_stride;
+			morph_attribs[i].index=i+8;
+		} else {
+			morph_attribs[i].enabled=false;
+		}
+
+		switch(i) {
+
+			case VS::ARRAY_VERTEX: {
+
+				if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
+					attribs[i].size=2;
+				} else {
+					attribs[i].size=3;
+				}
+
+				if (p_format&VS::ARRAY_COMPRESS_VERTEX) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=attribs[i].size*2;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=attribs[i].size*4;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+				if (has_morph) {
+					//morph
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=attribs[i].size*4;
+				}
+			} break;
+			case VS::ARRAY_NORMAL: {
+
+				attribs[i].size=3;
+
+				if (p_format&VS::ARRAY_COMPRESS_NORMAL) {
+					attribs[i].type=GL_BYTE;
+					stride+=4; //pad extra byte
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=12;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+				if (has_morph) {
+					//morph
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=12;
+				}
+
+			} break;
+			case VS::ARRAY_TANGENT: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_TANGENT) {
+					attribs[i].type=GL_BYTE;
+					stride+=4;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=16;
+				}
+
+			} break;
+			case VS::ARRAY_COLOR: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_COLOR) {
+					attribs[i].type=GL_UNSIGNED_BYTE;
+					stride+=4;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=16;
+				}
+
+			} break;
+			case VS::ARRAY_TEX_UV: {
+
+				attribs[i].size=2;
+
+				if (p_format&VS::ARRAY_COMPRESS_TEX_UV) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=4;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=8;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=8;
+				}
+
+			} break;
+			case VS::ARRAY_TEX_UV2: {
+
+				attribs[i].size=2;
+
+				if (p_format&VS::ARRAY_COMPRESS_TEX_UV2) {
+					attribs[i].type=GL_HALF_FLOAT;
+					stride+=4;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=8;
+				}
+				attribs[i].normalized=GL_FALSE;
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=8;
+				}
+
+			} break;
+			case VS::ARRAY_BONES: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_BONES) {
+
+					if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) {
+						attribs[i].type=GL_UNSIGNED_SHORT;
+						stride+=8;
+					} else {
+						attribs[i].type=GL_UNSIGNED_BYTE;
+						stride+=4;
+					}
+				} else {
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					stride+=8;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_UNSIGNED_SHORT;
+					morph_stride+=8;
+				}
+
+			} break;
+			case VS::ARRAY_WEIGHTS: {
+
+				attribs[i].size=4;
+
+				if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) {
+
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					stride+=8;
+					attribs[i].normalized=GL_TRUE;
+				} else {
+					attribs[i].type=GL_FLOAT;
+					stride+=16;
+					attribs[i].normalized=GL_FALSE;
+				}
+
+				if (has_morph) {
+					morph_attribs[i].normalized=GL_FALSE;
+					morph_attribs[i].size=attribs[i].size;
+					morph_attribs[i].type=GL_FLOAT;
+					morph_stride+=8;
+				}
+			} break;
+			case VS::ARRAY_INDEX: {
+
+				attribs[i].size=1;
+
+				if (p_vertex_count>=(1<<16)) {
+					attribs[i].type=GL_UNSIGNED_INT;
+					attribs[i].stride=4;
+				} else {
+					attribs[i].type=GL_UNSIGNED_SHORT;
+					attribs[i].stride=2;
+				}
+
+				attribs[i].normalized=GL_FALSE;
+
+			} break;
+
+		}
+	}
+
+	for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+		attribs[i].stride=stride;
+		if (has_morph) {
+			morph_attribs[i].stride=morph_stride;
+		}
+	}
+
+	//validate sizes
+
+	int array_size = stride * p_vertex_count;
+	int index_array_size=0;
+
+	ERR_FAIL_COND(p_array.size()!=array_size);
+
+	if (p_format&VS::ARRAY_FORMAT_INDEX) {
+
+		index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count;
+
+		print_line("index count: "+itos(p_index_count)+" stride: "+itos(attribs[VS::ARRAY_INDEX].stride) );
+	}
+
+
+	ERR_FAIL_COND(p_index_array.size()!=index_array_size);
+
+	ERR_FAIL_COND(p_blend_shapes.size()!=mesh->morph_target_count);
+
+	for(int i=0;i<p_blend_shapes.size();i++) {
+		ERR_FAIL_COND(p_blend_shapes[i].size()!=array_size);
+	}
+
+	//ok all valid, create stuff
+
+	Surface * surface = memnew( Surface );
+
+	surface->active=true;
+	surface->array_len=p_vertex_count;
+	surface->index_array_len=p_index_count;
+	surface->primitive=p_primitive;
+	surface->mesh=mesh;
+	surface->format=p_format;
+	surface->skeleton_bone_aabb=p_bone_aabbs;
+	surface->skeleton_bone_used.resize(surface->skeleton_bone_aabb.size());
+	surface->aabb=p_aabb;
+	surface->max_bone=p_bone_aabbs.size();
+
+	for(int i=0;i<surface->skeleton_bone_used.size();i++) {
+		if (surface->skeleton_bone_aabb[i].size.x<0 || surface->skeleton_bone_aabb[i].size.y<0 || surface->skeleton_bone_aabb[i].size.z<0) {
+			surface->skeleton_bone_used[i]=false;
+		} else {
+			surface->skeleton_bone_used[i]=true;
+		}
+	}
+
+	for(int i=0;i<VS::ARRAY_MAX;i++) {
+		surface->attribs[i]=attribs[i];
+		surface->morph_attribs[i]=morph_attribs[i];
+	}
+
+	{
+
+		DVector<uint8_t>::Read vr = p_array.read();
+
+		glGenBuffers(1,&surface->vertex_id);
+		glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+		glBufferData(GL_ARRAY_BUFFER,array_size,vr.ptr(),GL_STATIC_DRAW);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+
+		if (p_format&VS::ARRAY_FORMAT_INDEX) {
+
+			DVector<uint8_t>::Read ir = p_index_array.read();
+
+			glGenBuffers(1,&surface->index_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
+			glBufferData(GL_ELEMENT_ARRAY_BUFFER,index_array_size,ir.ptr(),GL_STATIC_DRAW);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
+		}
+
+		//generate arrays for faster state switching
+
+		glGenVertexArrays(1,&surface->array_id);
+		glBindVertexArray(surface->array_id);
+		glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+
+		for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+
+			if (!attribs[i].enabled)
+				continue;
+
+			glVertexAttribPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].normalized,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+			glEnableVertexAttribArray(attribs[i].index);
+
+		}
+
+		if (surface->index_id) {
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
+		}
+
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+	}
+
+	{
+
+		//blend shapes
+
+		for(int i=0;i<p_blend_shapes.size();i++) {
+
+			Surface::MorphTarget mt;
+
+			DVector<uint8_t>::Read vr = p_blend_shapes[i].read();
+
+			glGenBuffers(1,&mt.vertex_id);
+			glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
+			glBufferData(GL_ARRAY_BUFFER,array_size,vr.ptr(),GL_STATIC_DRAW);
+			glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+			glGenVertexArrays(1,&mt.array_id);
+			glBindVertexArray(mt.array_id);
+			glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
+
+			for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+
+				if (!attribs[i].enabled)
+					continue;
+
+				glVertexAttribPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].normalized,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+				glEnableVertexAttribArray(attribs[i].index);
+
+			}
+
+			glBindVertexArray(0);
+			glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+			surface->morph_targets.push_back(mt);
+
+		}
+	}
+
+	mesh->surfaces.push_back(surface);
+	mesh->instance_change_notify();
 }
 
 void RasterizerStorageGLES3::mesh_set_morph_target_count(RID p_mesh,int p_amount){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+
+	ERR_FAIL_COND(mesh->surfaces.size()!=0);
+	ERR_FAIL_COND(p_amount<0);
+
+	mesh->morph_target_count=p_amount;
 
 }
 int RasterizerStorageGLES3::mesh_get_morph_target_count(RID p_mesh) const{
 
-	return 0;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+
+	return mesh->morph_target_count;
 }
 
 
 void RasterizerStorageGLES3::mesh_set_morph_target_mode(RID p_mesh,VS::MorphTargetMode p_mode){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	mesh->morph_target_mode=p_mode;
 
 }
 VS::MorphTargetMode RasterizerStorageGLES3::mesh_get_morph_target_mode(RID p_mesh) const{
 
-	return VS::MORPH_MODE_NORMALIZED;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,VS::MORPH_MODE_NORMALIZED);
+
+	return mesh->morph_target_mode;
 }
 
 void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
+
+	mesh->surfaces[p_surface]->material=p_material;
 
 }
 RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{
 
-	return RID();
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,RID());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),RID());
+
+	return mesh->surfaces[p_surface]->material;
 }
 
 int RasterizerStorageGLES3::mesh_surface_get_array_len(RID p_mesh, int p_surface) const{
 
-	return 0;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
+
+	return mesh->surfaces[p_surface]->array_len;
+
 }
 int RasterizerStorageGLES3::mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const{
 
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
 
-	return 0;
+	return mesh->surfaces[p_surface]->index_array_len;
 }
 
 DVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{
 
-	return DVector<uint8_t>();
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,DVector<uint8_t>());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),DVector<uint8_t>());
+
+	Surface *surface = mesh->surfaces[p_surface];
+
+	glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+	void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_len,GL_MAP_READ_BIT);
+
+	ERR_FAIL_COND_V(!data,DVector<uint8_t>());
+
+	DVector<uint8_t> ret;
+	ret.resize(surface->array_len);
+
+	{
+
+		DVector<uint8_t>::Write w = ret.write();
+		copymem(w.ptr(),data,surface->array_len);
+	}
+	glUnmapBuffer(GL_ARRAY_BUFFER);
+
+
+	return ret;
 }
-DVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_mesh, int p_surface) const{
 
+DVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_mesh, int p_surface) const {
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,DVector<uint8_t>());
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),DVector<uint8_t>());
 
-	return DVector<uint8_t>();
+	Surface *surface = mesh->surfaces[p_surface];
+
+	ERR_FAIL_COND_V(surface->index_array_len==0,DVector<uint8_t>());
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->vertex_id);
+	void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,surface->index_array_len,GL_MAP_READ_BIT);
+
+	ERR_FAIL_COND_V(!data,DVector<uint8_t>());
+
+	DVector<uint8_t> ret;
+	ret.resize(surface->index_array_len);
+
+	{
+
+		DVector<uint8_t>::Write w = ret.write();
+		copymem(w.ptr(),data,surface->index_array_len);
+	}
+
+	glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+
+	return ret;
 }
 
 
 uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{
 
-	return 0;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+
+	ERR_FAIL_COND_V(!mesh,0);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),0);
+
+	return mesh->surfaces[p_surface]->format;
+
 }
+
 VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const{
 
-	return VS::PRIMITIVE_MAX;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,VS::PRIMITIVE_MAX);
+	ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),VS::PRIMITIVE_MAX);
+
+	return mesh->surfaces[p_surface]->primitive;
 }
 
-void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh,int p_index){
+void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_surface,mesh->surfaces.size());
 
+	Surface *surface = mesh->surfaces[p_surface];
+
+	ERR_FAIL_COND(surface->index_array_len==0);
+
+	glDeleteBuffers(1,&surface->array_id);
+	if (surface->index_id) {
+		glDeleteBuffers(1,&surface->index_id);
+	}
+
+	glDeleteVertexArrays(1,&surface->array_id);
+
+	for(int i=0;i<surface->morph_targets.size();i++) {
+
+		glDeleteBuffers(1,&surface->morph_targets[i].vertex_id);
+		glDeleteVertexArrays(1,&surface->morph_targets[i].array_id);
+	}
+
+	memdelete(surface);
+
+	mesh->surfaces.remove(p_surface);
+
+	mesh->instance_change_notify();
 }
 int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
 
-	return 0;
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,0);
+	return mesh->surfaces.size();
+
 }
 
 void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
 
+	mesh->custom_aabb=p_aabb;
 }
 AABB RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
 
-	return AABB();
+	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh,AABB());
+
+	return mesh->custom_aabb;
+
 }
 
-AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh) const{
+AABB RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
+
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND_V(!mesh,AABB());
+
+	if (mesh->custom_aabb!=AABB())
+		return mesh->custom_aabb;
+/*
+	Skeleton *sk=NULL;
+	if (p_skeleton.is_valid())
+		sk=skeleton_owner.get(p_skeleton);
+*/
+	AABB aabb;
+	/*
+	if (sk && sk->bones.size()!=0) {
+
+
+		for (int i=0;i<mesh->surfaces.size();i++) {
+
+			AABB laabb;
+			if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) {
+
+
+				int bs = mesh->surfaces[i]->skeleton_bone_aabb.size();
+				const AABB *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
+				const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
+
+				int sbs = sk->bones.size();
+				ERR_CONTINUE(bs>sbs);
+				Skeleton::Bone *skb = sk->bones.ptr();
+
+				bool first=true;
+				for(int j=0;j<bs;j++) {
+
+					if (!skused[j])
+						continue;
+					AABB baabb = skb[ j ].transform_aabb ( skbones[j] );
+					if (first) {
+						laabb=baabb;
+						first=false;
+					} else {
+						laabb.merge_with(baabb);
+					}
+				}
+
+			} else {
+
+				laabb=mesh->surfaces[i]->aabb;
+			}
+
+			if (i==0)
+				aabb=laabb;
+			else
+				aabb.merge_with(laabb);
+		}
+	} else {
+*/
+		for (int i=0;i<mesh->surfaces.size();i++) {
+
+			if (i==0)
+				aabb=mesh->surfaces[i]->aabb;
+			else
+				aabb.merge_with(mesh->surfaces[i]->aabb);
+		}
+/*
+	}
+*/
+	return aabb;
 
-	return AABB();
 }
 void RasterizerStorageGLES3::mesh_clear(RID p_mesh){
 
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
 
+	while(mesh->surfaces.size()) {
+		mesh_remove_surface(p_mesh,0);
+	}
 }
 
 /* MULTIMESH API */
@@ -2206,6 +2826,16 @@ void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::L
 
 }
 
+VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const {
+
+	return VS::LIGHT_DIRECTIONAL;
+}
+
+AABB RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
+
+	return AABB();
+}
+
 /* PROBE API */
 
 RID RasterizerStorageGLES3::reflection_probe_create(){
@@ -2292,6 +2922,42 @@ void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color
 
 }
 
+void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance) {
+
+	Instantiable *inst=NULL;
+	switch(p_instance->base_type) {
+		case VS::INSTANCE_MESH: {
+			inst = mesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+		} break;
+		default: {
+			ERR_FAIL();
+		}
+	}
+
+	inst->instance_list.add( &p_instance->dependency_item );
+}
+
+void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance){
+
+	Instantiable *inst=NULL;
+
+	switch(p_instance->base_type) {
+		case VS::INSTANCE_MESH: {
+			inst = mesh_owner.getornull(p_base);
+			ERR_FAIL_COND(!inst);
+
+		} break;
+		default: {
+			ERR_FAIL();
+		}
+	}
+
+	ERR_FAIL_COND(!inst);
+
+	inst->instance_list.remove( &p_instance->dependency_item );
+}
+
 
 /* RENDER TARGET */
 
@@ -2773,6 +3439,15 @@ void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder,
 
 }
 
+VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
+
+	if (mesh_owner.owns(p_rid)) {
+		return VS::INSTANCE_MESH;
+	}
+
+	return VS::INSTANCE_NONE;
+}
+
 bool RasterizerStorageGLES3::free(RID p_rid){
 
 	if (render_target_owner.owns(p_rid)) {
@@ -2834,6 +3509,15 @@ bool RasterizerStorageGLES3::free(RID p_rid){
 		material_owner.free(p_rid);
 		memdelete(material);
 
+	} else if (mesh_owner.owns(p_rid)) {
+
+		// delete the texture
+		Mesh *mesh = mesh_owner.get(p_rid);
+
+		mesh_clear(p_rid);
+
+		mesh_owner.free(p_rid);
+		memdelete(mesh);
 
 	} else if (canvas_occluder_owner.owns(p_rid)) {
 

drivers/gles3/rasterizer_storage_gles3.h

@@ -10,12 +10,14 @@
 #include "shader_compiler_gles3.h"
 
 class RasterizerCanvasGLES3;
+class RasterizerSceneGLES3;
 
 
 class RasterizerStorageGLES3 : public RasterizerStorage {
 public:
 
 	RasterizerCanvasGLES3 *canvas;
+	RasterizerSceneGLES3 *scene;
 
 	enum FBOFormat {
 		FBO_FORMAT_16_BITS,
@@ -59,6 +61,7 @@ public:
 		ShaderCompilerGLES3 compiler;
 
 		ShaderCompilerGLES3::IdentifierActions actions_canvas;
+		ShaderCompilerGLES3::IdentifierActions actions_scene;
 	} shaders;
 
 	struct Resources {
@@ -230,6 +233,40 @@ public:
 
 		} canvas_item;
 
+		struct Spatial {
+
+			enum BlendMode {
+				BLEND_MODE_MIX,
+				BLEND_MODE_ADD,
+				BLEND_MODE_SUB,
+				BLEND_MODE_MUL,
+			};
+
+			int blend_mode;
+
+			enum DepthDrawMode {
+				DEPTH_DRAW_OPAQUE,
+				DEPTH_DRAW_ALWAYS,
+				DEPTH_DRAW_NEVER,
+				DEPTH_DRAW_ALPHA_PREPASS,
+			};
+
+			int depth_draw_mode;
+
+			enum CullMode {
+				CULL_MODE_FRONT,
+				CULL_MODE_BACK,
+				CULL_MODE_DISABLED,
+			};
+
+			int cull_mode;
+
+			bool uses_alpha;
+			bool unshaded;
+			bool ontop;
+
+		} spatial;
+
 		Shader() : dirty_list(this) {
 
 			shader=NULL;
@@ -272,10 +309,14 @@ public:
 		SelfList<Material> dirty_list;
 		Vector<RID> textures;
 
+		uint32_t index;
+		uint64_t last_pass;
+
 		Material() : list(this), dirty_list(this) {
 			shader=NULL;
 			ubo_id=0;
 			ubo_size=0;
+			last_pass=0;
 		}
 
 	};
@@ -300,9 +341,155 @@ public:
 
 	/* MESH API */
 
+	struct Instantiable : public RID_Data {
+
+		enum Type {
+			GEOMETRY_INVALID,
+			GEOMETRY_SURFACE,
+			GEOMETRY_IMMEDIATE,
+			GEOMETRY_MULTISURFACE,
+		};
+
+		SelfList<RasterizerScene::InstanceBase>::List instance_list;
+
+		_FORCE_INLINE_ void instance_change_notify() {
+
+			SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
+			while(instances) {
+
+				instances->self()->base_changed();
+				instances=instances->next();
+			}
+		}
+
+		Instantiable() {  }
+		virtual ~Instantiable() {
+
+			while(instance_list.first()) {
+				instance_list.first()->self()->base_removed();
+			}
+		}
+	};
+
+	struct Geometry : Instantiable {
+
+		enum Type {
+			GEOMETRY_INVALID,
+			GEOMETRY_SURFACE,
+			GEOMETRY_IMMEDIATE,
+			GEOMETRY_MULTISURFACE,
+		};
+
+		Type type;
+		RID material;
+		uint64_t last_pass;
+		uint32_t index;
+
+		Geometry() {
+			last_pass=0;
+			index=0;
+		}
+
+	};
+
+	struct GeometryOwner : public Instantiable {
+
+		virtual ~GeometryOwner() {}
+	};
+
+	struct Mesh;
+	struct Surface : public Geometry {
+
+		struct Attrib {
+
+			bool enabled;
+			GLuint index;
+			GLint size;
+			GLenum type;
+			GLboolean normalized;
+			GLsizei stride;
+			uint32_t offset;
+		};
+
+		Attrib attribs[VS::ARRAY_MAX];
+		Attrib morph_attribs[VS::ARRAY_MAX];
+
+
+		Mesh *mesh;
+		uint32_t format;
+
+		GLuint array_id;
+		GLuint vertex_id;
+		GLuint index_id;
+
+		Vector<AABB> skeleton_bone_aabb;
+		Vector<bool> skeleton_bone_used;
+
+		//bool packed;
+
+		struct MorphTarget {
+			GLuint vertex_id;
+			GLuint array_id;
+		};
+
+		Vector<MorphTarget> morph_targets;
+
+		AABB aabb;
+
+		int array_len;
+		int index_array_len;
+		int max_bone;
+
+		int array_bytes;
+
+
+		VS::PrimitiveType primitive;
+
+		bool active;
+
+		Surface() {
+
+			array_bytes=0;
+			mesh=NULL;
+			format=0;
+			array_id=0;
+			vertex_id=0;
+			index_id=0;
+			array_len=0;
+			type=GEOMETRY_SURFACE;
+			primitive=VS::PRIMITIVE_POINTS;
+			index_array_len=0;
+			active=false;
+
+		}
+
+		~Surface() {
+
+		}
+	};
+
+
+	struct Mesh : public GeometryOwner {
+
+		bool active;
+		Vector<Surface*> surfaces;
+		int morph_target_count;
+		VS::MorphTargetMode morph_target_mode;
+		AABB custom_aabb;
+		mutable uint64_t last_pass;
+		Mesh() {
+			morph_target_mode=VS::MORPH_MODE_NORMALIZED;
+			morph_target_count=0;
+			last_pass=0;
+			active=false;
+		}
+	};
+
+	mutable RID_Owner<Mesh> mesh_owner;
+
 	virtual RID mesh_create();
 
-	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >());
+	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >(),const Vector<AABB>& p_bone_aabbs=Vector<AABB>());
 
 	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount);
 	virtual int mesh_get_morph_target_count(RID p_mesh) const;
@@ -324,13 +511,13 @@ public:
 	virtual uint32_t mesh_surface_get_format(RID p_mesh, int p_surface) const;
 	virtual VS::PrimitiveType mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const;
 
-	virtual void mesh_remove_surface(RID p_mesh,int p_index);
+	virtual void mesh_remove_surface(RID p_mesh, int p_surface);
 	virtual int mesh_get_surface_count(RID p_mesh) const;
 
 	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb);
 	virtual AABB mesh_get_custom_aabb(RID p_mesh) const;
 
-	virtual AABB mesh_get_aabb(RID p_mesh) const;
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton) const;
 	virtual void mesh_clear(RID p_mesh);
 
 	/* MULTIMESH API */
@@ -401,6 +588,8 @@ public:
 
 	virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode);
 
+	virtual VS::LightType light_get_type(RID p_light) const;
+	virtual AABB light_get_aabb(RID p_light) const;
 	/* PROBE API */
 
 	virtual RID reflection_probe_create();
@@ -434,6 +623,9 @@ public:
 	virtual void portal_set_disabled_color(RID p_portal, const Color& p_color);
 
 
+	virtual void instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
+	virtual void instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
+
 	/* RENDER TARGET */
 
 	struct RenderTarget : public RID_Data {
@@ -522,6 +714,8 @@ public:
 	virtual RID canvas_light_occluder_create();
 	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines);
 
+	virtual VS::InstanceType get_base_type(RID p_rid) const;
+
 	virtual bool free(RID p_rid);
 
 

drivers/gles3/shader_gles3.cpp

@@ -662,8 +662,8 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
 			fragment_code0=code.ascii();
 		} else {
 			fragment_code0=code.substr(0,cpos).ascii();
-			code = code.substr(cpos+globals_tag.length(),code.length());
+			//print_line("CODE0:\n"+String(fragment_code0.get_data()));
-
+			code = code.substr(cpos+globals_tag.length(),code.length());			
 			cpos = code.find(material_tag);
 
 			if (cpos==-1) {
@@ -671,14 +671,18 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
 			} else {
 
 				fragment_code1=code.substr(0,cpos).ascii();
-				String code2 = code.substr(cpos+material_tag.length(),code.length());
+				//print_line("CODE1:\n"+String(fragment_code1.get_data()));
 
+				String code2 = code.substr(cpos+material_tag.length(),code.length());
 				cpos = code2.find(code_tag);
+
 				if (cpos==-1) {
 					fragment_code2=code2.ascii();
 				} else {
 
 					fragment_code2=code2.substr(0,cpos).ascii();
+					//print_line("CODE2:\n"+String(fragment_code2.get_data()));
+
 					String code3 = code2.substr(cpos+code_tag.length(),code2.length());
 
 					cpos = code3.find(light_code_tag);
@@ -687,7 +691,9 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
 					} else {
 
 						fragment_code3=code3.substr(0,cpos).ascii();
+					//	print_line("CODE3:\n"+String(fragment_code3.get_data()));
 						fragment_code4 = code3.substr(cpos+light_code_tag.length(),code3.length()).ascii();
+						//print_line("CODE4:\n"+String(fragment_code4.get_data()));
 					}
 				}
 			}

drivers/gles3/shaders/SCsub

@@ -4,4 +4,5 @@ if env['BUILDERS'].has_key('GLES3_GLSL'):
 	env.GLES3_GLSL('copy.glsl');
 	env.GLES3_GLSL('canvas.glsl');
 	env.GLES3_GLSL('canvas_shadow.glsl');
+	env.GLES3_GLSL('scene.glsl');
 

drivers/gles3/shaders/scene.glsl

@@ -0,0 +1,351 @@
+[vertex]
+
+
+
+/*
+from VisualServer:
+
+ARRAY_VERTEX=0,
+ARRAY_NORMAL=1,
+ARRAY_TANGENT=2,
+ARRAY_COLOR=3,
+ARRAY_TEX_UV=4,
+ARRAY_TEX_UV2=5,
+ARRAY_BONES=6,
+ARRAY_WEIGHTS=7,
+ARRAY_INDEX=8,
+*/
+
+//hack to use uv if no uv present so it works with lightmap
+
+
+/* INPUT ATTRIBS */
+
+layout(location=0) in highp vec4 vertex_attrib;
+layout(location=1) in vec3 normal_attrib;
+layout(location=2) in vec4 tangent_attrib;
+layout(location=3) in vec4 color_attrib;
+layout(location=4) in vec2 uv_attrib;
+layout(location=5) in vec2 uv2_attrib;
+
+uniform float normal_mult;
+
+#ifdef USE_SKELETON
+layout(location=6) mediump ivec4 bone_indices; // attrib:6
+layout(location=7) mediump vec4 bone_weights; // attrib:7
+uniform highp sampler2D skeleton_matrices;
+#endif
+
+#ifdef USE_ATTRIBUTE_INSTANCING
+
+layout(location=8) in highp vec4 instance_xform0;
+layout(location=9) in highp vec4 instance_xform1;
+layout(location=10) in highp vec4 instance_xform2;
+layout(location=11) in lowp vec4 instance_color;
+
+#endif
+
+layout(std140) uniform SceneData { //ubo:0
+
+	highp mat4 projection_matrix;
+	highp mat4 camera_inverse_matrix;
+	highp mat4 camera_matrix;
+	highp vec4 time;
+
+	highp vec4 ambient_light;
+};
+
+uniform highp mat4 world_transform;
+
+/* Varyings */
+
+out vec3 vertex_interp;
+out vec3 normal_interp;
+
+#if defined(ENABLE_COLOR_INTERP)
+out vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+out vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+out vec2 uv2_interp;
+#endif
+
+#if defined(ENABLE_VAR1_INTERP)
+out vec4 var1_interp;
+#endif
+
+#if defined(ENABLE_VAR2_INTERP)
+out vec4 var2_interp;
+#endif
+
+#if defined(ENABLE_TANGENT_INTERP)
+out vec3 tangent_interp;
+out vec3 binormal_interp;
+#endif
+
+
+#if !defined(USE_DEPTH_SHADOWS) && defined(USE_SHADOW_PASS)
+
+varying vec4 position_interp;
+
+#endif
+
+#ifdef USE_SHADOW_PASS
+
+uniform highp float shadow_z_offset;
+uniform highp float shadow_z_slope_scale;
+
+#endif
+
+
+VERTEX_SHADER_GLOBALS
+
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData { //ubo:1
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+
+void main() {
+
+	highp vec4 vertex_in = vertex_attrib; // vec4(vertex_attrib.xyz * data_attrib.x,1.0);
+	highp mat4 modelview = camera_inverse_matrix * world_transform;
+	vec3 normal_in = normal_attrib;
+	normal_in*=normal_mult;
+#if defined(ENABLE_TANGENT_INTERP)
+	vec3 tangent_in = tangent_attrib.xyz;
+	tangent_in*=normal_mult;
+	float binormalf = tangent_attrib.a;
+#endif
+
+#ifdef USE_SKELETON
+
+	{
+		//skeleton transform
+		highp mat4 m=mat4(texture2D(skeleton_matrices,vec2((bone_indices.x*3.0+0.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.x*3.0+1.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.x*3.0+2.0)*skeltex_pixel_size,0.0)),vec4(0.0,0.0,0.0,1.0))*bone_weights.x;
+		m+=mat4(texture2D(skeleton_matrices,vec2((bone_indices.y*3.0+0.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.y*3.0+1.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.y*3.0+2.0)*skeltex_pixel_size,0.0)),vec4(0.0,0.0,0.0,1.0))*bone_weights.y;
+		m+=mat4(texture2D(skeleton_matrices,vec2((bone_indices.z*3.0+0.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.z*3.0+1.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.z*3.0+2.0)*skeltex_pixel_size,0.0)),vec4(0.0,0.0,0.0,1.0))*bone_weights.z;
+		m+=mat4(texture2D(skeleton_matrices,vec2((bone_indices.w*3.0+0.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.w*3.0+1.0)*skeltex_pixel_size,0.0)),texture2D(skeleton_matrices,vec2((bone_indices.w*3.0+2.0)*skeltex_pixel_size,0.0)),vec4(0.0,0.0,0.0,1.0))*bone_weights.w;
+
+		vertex_in = vertex_in * m;
+		normal_in = (vec4(normal_in,0.0) * m).xyz;
+#if defined(ENABLE_TANGENT_INTERP)
+		tangent_in = (vec4(tangent_in,0.0) * m).xyz;
+#endif
+	}
+
+#endif
+
+	vertex_interp = (modelview * vertex_in).xyz;
+	normal_interp = normalize((modelview * vec4(normal_in,0.0)).xyz);
+
+#if defined(ENABLE_TANGENT_INTERP)
+	tangent_interp=normalize((modelview * vec4(tangent_in,0.0)).xyz);
+	binormal_interp = normalize( cross(normal_interp,tangent_interp) * binormalf );
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+	color_interp = color_attrib;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+	uv_interp = uv_attrib;
+#endif
+#if defined(ENABLE_UV2_INTERP)
+	uv2_interp = uv2_attrib;
+#endif
+
+
+VERTEX_SHADER_CODE
+
+
+#ifdef USE_SHADOW_PASS
+
+	float z_ofs = shadow_z_offset;
+	z_ofs += (1.0-abs(normal_interp.z))*shadow_z_slope_scale;
+	vertex_interp.z-=z_ofs;
+#endif
+
+
+#ifdef USE_FOG
+
+	fog_interp.a = pow( clamp( (length(vertex_interp)-fog_params.x)/(fog_params.y-fog_params.x), 0.0, 1.0 ), fog_params.z );
+	fog_interp.rgb = mix( fog_color_begin, fog_color_end, fog_interp.a );
+#endif
+
+#ifndef VERTEX_SHADER_WRITE_POSITION
+//vertex shader might write a position
+	gl_Position = projection_matrix * vec4(vertex_interp,1.0);
+#endif
+
+
+
+
+}
+
+
+[fragment]
+
+
+//hack to use uv if no uv present so it works with lightmap
+
+
+/* Varyings */
+
+#if defined(ENABLE_COLOR_INTERP)
+in vec4 color_interp;
+#endif
+
+#if defined(ENABLE_UV_INTERP)
+in vec2 uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+in vec2 uv2_interp;
+#endif
+
+#if defined(ENABLE_TANGENT_INTERP)
+in vec3 tangent_interp;
+in vec3 binormal_interp;
+#endif
+
+#if defined(ENABLE_VAR1_INTERP)
+in vec4 var1_interp;
+#endif
+
+#if defined(ENABLE_VAR2_INTERP)
+in vec4 var2_interp;
+#endif
+
+in vec3 vertex_interp;
+in vec3 normal_interp;
+
+
+/* Material Uniforms */
+
+
+FRAGMENT_SHADER_GLOBALS
+
+
+#if defined(USE_MATERIAL)
+
+layout(std140) uniform UniformData {
+
+MATERIAL_UNIFORMS
+
+};
+
+#endif
+
+
+layout(std140) uniform SceneData {
+
+	highp mat4 projection_matrix;
+	highp mat4 camera_inverse_matrix;
+	highp mat4 camera_matrix;
+	highp vec4 time;
+
+	highp vec4 ambient_light;
+};
+
+layout(location=0) out vec4 frag_color;
+
+void main() {
+
+	//lay out everything, whathever is unused is optimized away anyway
+	vec3 vertex = vertex_interp;
+	vec3 albedo = vec3(0.9,0.9,0.9);
+	vec3 metal = vec3(0.0,0.0,0.0);
+	float rough = 0.0;
+	float alpha = 1.0;
+
+#ifdef METERIAL_DOUBLESIDED
+	float side=float(gl_FrontFacing)*2.0-1.0;
+#else
+	float side=1.0;
+#endif
+
+
+#if defined(ENABLE_TANGENT_INTERP)
+	vec3 binormal = normalize(binormal_interp)*side;
+	vec3 tangent = normalize(tangent_interp)*side;
+#endif
+	vec3 normal = normalize(normal_interp)*side;
+
+#if defined(ENABLE_UV_INTERP)
+	vec2 uv = uv_interp;
+#endif
+
+#if defined(ENABLE_UV2_INTERP)
+	vec2 uv2 = uv2_interp;
+#endif
+
+#if defined(ENABLE_COLOR_INTERP)
+	vec4 color = color_interp;
+#endif
+
+#if defined(ENABLE_NORMALMAP)
+
+	vec3 normalmap = vec3(0.0);
+#endif
+
+	float normaldepth=1.0;
+
+
+
+#if defined(ENABLE_DISCARD)
+	bool discard_=false;
+#endif
+
+{
+
+
+FRAGMENT_SHADER_CODE
+
+}
+
+#if defined(ENABLE_NORMALMAP)
+
+	normal = normalize( mix(normal_interp,tangent_interp * normalmap.x + binormal_interp * normalmap.y + normal_interp * normalmap.z,normaldepth) ) * side;
+
+#endif
+
+#if defined(ENABLE_DISCARD)
+	if (discard_) {
+	//easy to eliminate dead code
+		discard;
+	}
+#endif
+
+#ifdef ENABLE_CLIP_ALPHA
+	if (diffuse.a<0.99) {
+		//used for doublepass and shadowmapping
+		discard;
+	}
+#endif
+
+
+
+#if defined(USE_LIGHT_SHADER_CODE)
+//light is written by the light shader
+{
+
+LIGHT_SHADER_CODE
+
+}
+#endif
+
+	frag_color=vec4(albedo,alpha);
+}
+
+

servers/visual/rasterizer.h

@@ -33,6 +33,75 @@
 #include "servers/visual_server.h"
 #include "camera_matrix.h"
 
+#include "self_list.h"
+
+
+class RasterizerScene {
+public:
+
+
+	struct InstanceBase : RID_Data {
+
+		VS::InstanceType base_type;
+		RID base;
+
+		RID skeleton;
+		RID material_override;
+
+		Transform transform;
+
+		int depth_layer;
+
+		//RID sampled_light;
+
+		Vector<RID> materials;
+		Vector<RID> light_instances;
+
+		Vector<float> morph_values;
+
+		//BakedLightData *baked_light;
+		VS::ShadowCastingSetting cast_shadows;
+		//Transform *baked_light_octree_xform;
+		//int baked_lightmap_id;
+
+		bool mirror :8;
+		bool depth_scale :8;
+		bool billboard :8;
+		bool billboard_y :8;
+		bool receive_shadows : 8;
+
+		SelfList<InstanceBase> dependency_item;
+
+		virtual void base_removed()=0;
+		virtual void base_changed()=0;
+
+		InstanceBase() : dependency_item(this) {
+
+			base_type=VS::INSTANCE_NONE;
+			cast_shadows=VS::SHADOW_CASTING_SETTING_ON;
+			receive_shadows=true;
+			depth_scale=false;
+			billboard=false;
+			billboard_y=false;
+			depth_layer=0;
+
+		}
+	};
+
+	virtual RID light_instance_create(RID p_light)=0;
+	virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform)=0;
+
+	virtual void render_scene(const Transform& p_cam_transform,CameraMatrix& p_cam_projection,bool p_cam_ortogonal,InstanceBase** p_cull_result,int p_cull_count,RID* p_light_cull_result,int p_light_cull_count,RID* p_directional_lights,int p_directional_light_count,RID p_environment)=0;
+
+	virtual bool free(RID p_rid)=0;
+
+	virtual ~RasterizerScene() {}
+};
+
+
+
+
+
 
 
 class RasterizerStorage {
@@ -88,7 +157,7 @@ public:
 
 	virtual RID mesh_create()=0;
 
-	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >())=0;
+	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >(),const Vector<AABB>& p_bone_aabbs=Vector<AABB>())=0;
 
 	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount)=0;
 	virtual int mesh_get_morph_target_count(RID p_mesh) const=0;
@@ -116,7 +185,7 @@ public:
 	virtual void mesh_set_custom_aabb(RID p_mesh,const AABB& p_aabb)=0;
 	virtual AABB mesh_get_custom_aabb(RID p_mesh) const=0;
 
-	virtual AABB mesh_get_aabb(RID p_mesh) const=0;
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton) const=0;
 	virtual void mesh_clear(RID p_mesh)=0;
 
 	/* MULTIMESH API */
@@ -184,9 +253,11 @@ public:
 	virtual void light_set_cull_mask(RID p_light,uint32_t p_mask)=0;
 	virtual void light_set_shader(RID p_light,RID p_shader)=0;
 
-
 	virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode)=0;
 
+	virtual VS::LightType light_get_type(RID p_light) const=0;
+	virtual AABB light_get_aabb(RID p_light) const=0;
+
 	/* PROBE API */
 
 	virtual RID reflection_probe_create()=0;
@@ -220,6 +291,10 @@ public:
 	virtual void portal_set_disabled_color(RID p_portal, const Color& p_color)=0;
 
 
+
+	virtual void instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance)=0;
+	virtual void instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance)=0;
+
 	/* RENDER TARGET */
 
 	enum RenderTargetFlags {
@@ -246,6 +321,8 @@ public:
 	virtual RID canvas_light_occluder_create()=0;
 	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines)=0;
 
+
+	virtual VS::InstanceType get_base_type(RID p_rid) const=0;
 	virtual bool free(RID p_rid)=0;
 
 
@@ -257,6 +334,7 @@ public:
 
 
 
+
 class RasterizerCanvas {
 public:
 
@@ -563,7 +641,7 @@ public:
 					case Item::Command::TYPE_MESH: {
 
 						const Item::CommandMesh* mesh = static_cast< const Item::CommandMesh*>(c);
-						AABB aabb = RasterizerStorage::base_signleton->mesh_get_aabb(mesh->mesh);
+						AABB aabb = RasterizerStorage::base_signleton->mesh_get_aabb(mesh->mesh,mesh->skeleton);
 
 						r=Rect2(aabb.pos.x,aabb.pos.y,aabb.size.x,aabb.size.y);
 
@@ -654,17 +732,6 @@ public:
 };
 
 
-
-class RasterizerScene {
-public:
-
-
-
-	virtual ~RasterizerScene() {}
-};
-
-
-
 class Rasterizer {
 protected:
 	static Rasterizer* (*_create_func)();
@@ -689,8 +756,6 @@ public:
 };
 
 
-
-
 #if 0
 /**
 	@author Juan Linietsky <reduzio@gmail.com>

servers/visual/shader_types.cpp

@@ -58,8 +58,8 @@ ShaderTypes::ShaderTypes()
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["NORMAL"]=ShaderLanguage::TYPE_VEC3;
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["ALBEDO"]=ShaderLanguage::TYPE_VEC3;
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["ALPHA"]=ShaderLanguage::TYPE_FLOAT;
-	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["METAL"]=ShaderLanguage::TYPE_FLOAT;
+	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["SPECULAR"]=ShaderLanguage::TYPE_VEC3;
-	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["ROUGH"]=ShaderLanguage::TYPE_FLOAT;
+	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["ROUGHNESS"]=ShaderLanguage::TYPE_FLOAT;
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["EMISSION"]=ShaderLanguage::TYPE_VEC3;
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["SPECIAL"]=ShaderLanguage::TYPE_FLOAT;
 	shader_modes[VS::SHADER_SPATIAL].functions["fragment"]["DISCARD"]=ShaderLanguage::TYPE_BOOL;
@@ -77,10 +77,6 @@ ShaderTypes::ShaderTypes()
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_sub");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_mul");
 
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("special_glow");
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("special_subsurf");
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("special_specular");
-
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("depth_draw_opaque");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("depth_draw_always");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("depth_draw_never");
@@ -90,12 +86,10 @@ ShaderTypes::ShaderTypes()
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("cull_back");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("cull_disable");
 
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("lightmap_on_uv2");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("unshaded");
 	shader_modes[VS::SHADER_SPATIAL].modes.insert("ontop");
 
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("vertex_model_space");
+	shader_modes[VS::SHADER_SPATIAL].modes.insert("skip_transform");
-	shader_modes[VS::SHADER_SPATIAL].modes.insert("vertex_camera_space");
 
 	/************ CANVAS ITEM **************************/
 
@@ -158,4 +152,5 @@ ShaderTypes::ShaderTypes()
 
 
 
+
 }

servers/visual/visual_server_raster.cpp

@@ -34,183 +34,12 @@
 #include "io/marshalls.h"
 #include "visual_server_canvas.h"
 #include "visual_server_global.h"
+#include "visual_server_scene.h"
 
 // careful, these may run in different threads than the visual server
 
 
 
-/* CAMERA API */
-
-RID VisualServerRaster::camera_create() {
-
-	return RID();
-}
-void VisualServerRaster::camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far) {
-
-}
-void VisualServerRaster::camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far){
-
-}
-void VisualServerRaster::camera_set_transform(RID p_camera,const Transform& p_transform) {
-
-}
-void VisualServerRaster::camera_set_cull_mask(RID p_camera,uint32_t p_layers){
-
-}
-void VisualServerRaster::camera_set_environment(RID p_camera,RID p_env){
-
-}
-void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera,bool p_enable){
-
-}
-
-
-/* ENVIRONMENT API */
-
-RID VisualServerRaster::environment_create(){
-
-	return RID();
-}
-
-void VisualServerRaster::environment_set_background(RID p_env,EnvironmentBG p_bg){
-
-}
-void VisualServerRaster::environment_set_skybox(RID p_env,RID p_skybox,float p_energy){
-
-}
-void VisualServerRaster::environment_set_bg_color(RID p_env,const Color& p_color){
-
-}
-void VisualServerRaster::environment_set_canvas_max_layer(RID p_env,int p_max_layer){
-
-}
-void VisualServerRaster::environment_set_ambient_light(RID p_env,const Color& p_color,float p_energy){
-
-}
-
-void VisualServerRaster::environment_set_glow(RID p_env,bool p_enable,int p_radius,float p_intensity,float p_strength,float p_bloom_treshold,EnvironmentGlowBlendMode p_blend_mode){
-
-}
-void VisualServerRaster::environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture){
-
-}
-
-void VisualServerRaster::environment_set_tonemap(RID p_env,bool p_enable,float p_exposure,float p_white,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,EnvironmentToneMapper p_tone_mapper){
-
-}
-void VisualServerRaster::environment_set_brightness(RID p_env,bool p_enable,float p_brightness){
-
-}
-void VisualServerRaster::environment_set_contrast(RID p_env,bool p_enable,float p_contrast){
-
-}
-void VisualServerRaster::environment_set_saturation(RID p_env,bool p_enable,float p_saturation){
-
-}
-void VisualServerRaster::environment_set_color_correction(RID p_env,bool p_enable,RID p_ramp){
-
-}
-
-
-/* SCENARIO API */
-
-
-RID VisualServerRaster::scenario_create() {
-
-	return RID();
-}
-
-void VisualServerRaster::scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode){
-
-}
-void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment){
-
-}
-RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment) const{
-
-	return RID();
-}
-void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment){
-
-}
-
-
-/* INSTANCING API */
-// from can be mesh, light,  area and portal so far.
-RID VisualServerRaster::instance_create(){
-
-	return RID();
-}
-
-void VisualServerRaster::instance_set_base(RID p_instance, RID p_base){
-
-}
-void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario){
-
-}
-void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask){
-
-}
-void VisualServerRaster::instance_set_transform(RID p_instance, const Transform& p_transform){
-
-}
-void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance,ObjectID p_ID){
-
-}
-void VisualServerRaster::instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight){
-
-}
-void VisualServerRaster::instance_set_surface_material(RID p_instance,int p_surface, RID p_material){
-
-}
-
-void VisualServerRaster::instance_attach_skeleton(RID p_instance,RID p_skeleton){
-
-}
-void VisualServerRaster::instance_set_exterior( RID p_instance, bool p_enabled ){
-
-}
-void VisualServerRaster::instance_set_room( RID p_instance, RID p_room ){
-
-}
-
-void VisualServerRaster::instance_set_extra_visibility_margin( RID p_instance, real_t p_margin ){
-
-}
-
-// don't use these in a game!
-Vector<ObjectID> VisualServerRaster::instances_cull_aabb(const AABB& p_aabb, RID p_scenario) const{
-
-	return Vector<ObjectID>();
-}
-
-Vector<ObjectID> VisualServerRaster::instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario) const{
-
-	return Vector<ObjectID>();
-}
-Vector<ObjectID> VisualServerRaster::instances_cull_convex(const Vector<Plane>& p_convex, RID p_scenario) const {
-
-	return Vector<ObjectID>();
-}
-
-
-void VisualServerRaster::instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled){
-
-}
-void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, ShadowCastingSetting p_shadow_casting_setting) {
-
-}
-void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material){
-
-}
-
-
-void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max,float p_min_margin,float p_max_margin){
-
-}
-void VisualServerRaster::instance_geometry_set_as_instance_lod(RID p_instance,RID p_as_lod_of_instance){
-
-}
 
 /* CURSOR */
 void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor ){
@@ -247,6 +76,8 @@ void VisualServerRaster::free( RID p_rid ){
 		return;
 	if (VSG::viewport->free(p_rid))
 		return;
+	if (VSG::scene->free(p_rid))
+		return;
 
 }
 
@@ -258,6 +89,9 @@ void VisualServerRaster::draw(){
 	//	print_line("changes: "+itos(changes));
 
 	changes=0;
+
+	VSG::scene->update_dirty_instances(); //update scene stuff
+
 	VSG::rasterizer->begin_frame();
 	VSG::viewport->draw_viewports();
 	//_draw_cursors_and_margins();
@@ -322,6 +156,7 @@ VisualServerRaster::VisualServerRaster() {
 
 	VSG::canvas = memnew( VisualServerCanvas);
 	VSG::viewport = memnew( VisualServerViewport);
+	VSG::scene = memnew( VisualServerScene );
 	VSG::rasterizer = Rasterizer::create();
 	VSG::storage=VSG::rasterizer->get_storage();
 	VSG::canvas_render=VSG::rasterizer->get_canvas();

servers/visual/visual_server_raster.h

@@ -37,6 +37,7 @@
 #include "visual_server_global.h"
 #include "visual_server_viewport.h"
 #include "visual_server_canvas.h"
+#include "visual_server_scene.h"
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
@@ -600,6 +601,7 @@ public:
 #define BIND6(m_name,m_type1,m_type2,m_type3,m_type4,m_type5,m_type6) void m_name(m_type1 arg1,m_type2 arg2,m_type3 arg3,m_type4 arg4,m_type5 arg5,m_type6 arg6) { DISPLAY_CHANGED BINDBASE->m_name(arg1,arg2,arg3,arg4,arg5,arg6); }
 #define BIND7(m_name,m_type1,m_type2,m_type3,m_type4,m_type5,m_type6,m_type7) void m_name(m_type1 arg1,m_type2 arg2,m_type3 arg3,m_type4 arg4,m_type5 arg5,m_type6 arg6,m_type7 arg7) { DISPLAY_CHANGED BINDBASE->m_name(arg1,arg2,arg3,arg4,arg5,arg6,arg7); }
 #define BIND8(m_name,m_type1,m_type2,m_type3,m_type4,m_type5,m_type6,m_type7,m_type8) void m_name(m_type1 arg1,m_type2 arg2,m_type3 arg3,m_type4 arg4,m_type5 arg5,m_type6 arg6,m_type7 arg7,m_type8 arg8) { DISPLAY_CHANGED BINDBASE->m_name(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); }
+#define BIND9(m_name,m_type1,m_type2,m_type3,m_type4,m_type5,m_type6,m_type7,m_type8,m_type9) void m_name(m_type1 arg1,m_type2 arg2,m_type3 arg3,m_type4 arg4,m_type5 arg5,m_type6 arg6,m_type7 arg7,m_type8 arg8,m_type9 arg9) { DISPLAY_CHANGED BINDBASE->m_name(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); }
 #define BIND10(m_name,m_type1,m_type2,m_type3,m_type4,m_type5,m_type6,m_type7,m_type8,m_type9,m_type10) void m_name(m_type1 arg1,m_type2 arg2,m_type3 arg3,m_type4 arg4,m_type5 arg5,m_type6 arg6,m_type7 arg7,m_type8 arg8,m_type9 arg9,m_type10 arg10) { DISPLAY_CHANGED BINDBASE->m_name(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); }
 
 //from now on, calls forwarded to this singleton
@@ -659,7 +661,7 @@ public:
 
 	BIND0R(RID,mesh_create)
 
-	BIND8(mesh_add_surface,RID,uint32_t,PrimitiveType,const DVector<uint8_t>&,int ,const DVector<uint8_t>& ,int ,const Vector<DVector<uint8_t> >& )
+	BIND10(mesh_add_surface,RID,uint32_t,PrimitiveType,const DVector<uint8_t>&,int ,const DVector<uint8_t>& ,int ,const AABB&,const Vector<DVector<uint8_t> >&,const Vector<AABB>& )
 
 	BIND2(mesh_set_morph_target_count,RID,int)
 	BIND1RC(int,mesh_get_morph_target_count,RID)
@@ -788,13 +790,18 @@ public:
 
 	/* CAMERA API */
 
-	virtual RID camera_create();
+#undef BINDBASE
-	virtual void camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far);
+//from now on, calls forwarded to this singleton
-	virtual void camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far);
+#define BINDBASE VSG::scene
-	virtual void camera_set_transform(RID p_camera,const Transform& p_transform);
+
-	virtual void camera_set_cull_mask(RID p_camera,uint32_t p_layers);
+
-	virtual void camera_set_environment(RID p_camera,RID p_env);
+	BIND0R(RID, camera_create)
-	virtual void camera_set_use_vertical_aspect(RID p_camera,bool p_enable);
+	BIND4(camera_set_perspective,RID,float, float , float )
+	BIND4(camera_set_orthogonal,RID,float , float , float )
+	BIND2(camera_set_transform,RID,const Transform&)
+	BIND2(camera_set_cull_mask,RID,uint32_t )
+	BIND2(camera_set_environment,RID ,RID )
+	BIND2(camera_set_use_vertical_aspect,RID,bool)
 
 #undef BINDBASE
 //from now on, calls forwarded to this singleton
@@ -839,66 +846,69 @@ public:
 
 	/* ENVIRONMENT API */
 
-	virtual RID environment_create();
+#undef BINDBASE
+//from now on, calls forwarded to this singleton
+#define BINDBASE VSG::scene
 
-	virtual void environment_set_background(RID p_env,EnvironmentBG p_bg);
+	BIND0R(RID,environment_create)
-	virtual void environment_set_skybox(RID p_env,RID p_skybox,float p_energy=1.0);
-	virtual void environment_set_bg_color(RID p_env,const Color& p_color);
-	virtual void environment_set_canvas_max_layer(RID p_env,int p_max_layer);
-	virtual void environment_set_ambient_light(RID p_env,const Color& p_color,float p_energy=1.0);
 
-	virtual void environment_set_glow(RID p_env,bool p_enable,int p_radius,float p_intensity,float p_strength,float p_bloom_treshold,EnvironmentGlowBlendMode p_blend_mode);
+	BIND2(environment_set_background,RID ,EnvironmentBG )
-	virtual void environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture);
+	BIND3(environment_set_skybox,RID,RID ,float )
+	BIND2(environment_set_bg_color,RID,const Color& )
+	BIND2(environment_set_canvas_max_layer,RID,int )
+	BIND3(environment_set_ambient_light,RID,const Color& ,float )
 
-	virtual void environment_set_tonemap(RID p_env,bool p_enable,float p_exposure,float p_white,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,EnvironmentToneMapper p_tone_mapper);
+	BIND7(environment_set_glow,RID,bool ,int ,float ,float ,float ,EnvironmentGlowBlendMode )
-	virtual void environment_set_brightness(RID p_env,bool p_enable,float p_brightness);
+	BIND5(environment_set_fog,RID,bool ,float ,float ,RID )
-	virtual void environment_set_contrast(RID p_env,bool p_enable,float p_contrast);
+
-	virtual void environment_set_saturation(RID p_env,bool p_enable,float p_saturation);
+	BIND8(environment_set_tonemap,RID,bool ,float ,float ,float ,float ,float ,EnvironmentToneMapper )
-	virtual void environment_set_color_correction(RID p_env,bool p_enable,RID p_ramp);
+	BIND3(environment_set_brightness,RID,bool ,float )
+	BIND3(environment_set_contrast,RID,bool ,float )
+	BIND3(environment_set_saturation,RID,bool ,float )
+	BIND3(environment_set_color_correction,RID,bool ,RID )
 
 
 	/* SCENARIO API */
 
 
-	virtual RID scenario_create();
+	BIND0R(RID,scenario_create)
 
-	virtual void scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode);
+	BIND2(scenario_set_debug,RID,ScenarioDebugMode )
-	virtual void scenario_set_environment(RID p_scenario, RID p_environment);
+	BIND2(scenario_set_environment,RID, RID )
-	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const;
+	BIND2(scenario_set_fallback_environment,RID, RID )
-	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
 
 
 	/* INSTANCING API */
  // from can be mesh, light,  area and portal so far.
-	virtual RID instance_create(); // from can be mesh, light, poly, area and portal so far.
+	BIND0R(RID,instance_create)
 
-	virtual void instance_set_base(RID p_instance, RID p_base); // from can be mesh, light, poly, area and portal so far.
+	BIND2(instance_set_base,RID, RID ) // from can be mesh, light, poly, area and portal so far.
-	virtual void instance_set_scenario(RID p_instance, RID p_scenario); // from can be mesh, light, poly, area and portal so far.
+	BIND2(instance_set_scenario,RID, RID ) // from can be mesh, light, poly, area and portal so far.
-	virtual void instance_set_layer_mask(RID p_instance, uint32_t p_mask);
+	BIND2(instance_set_layer_mask,RID, uint32_t )
-	virtual void instance_set_transform(RID p_instance, const Transform& p_transform);
+	BIND2(instance_set_transform,RID, const Transform& )
-	virtual void instance_attach_object_instance_ID(RID p_instance,ObjectID p_ID);
+	BIND2(instance_attach_object_instance_ID,RID,ObjectID )
-	virtual void instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight);
+	BIND3(instance_set_morph_target_weight,RID,int , float )
-	virtual void instance_set_surface_material(RID p_instance,int p_surface, RID p_material);
+	BIND3(instance_set_surface_material,RID,int , RID )
 
-	virtual void instance_attach_skeleton(RID p_instance,RID p_skeleton);
+	BIND2(instance_attach_skeleton,RID,RID )
-	virtual void instance_set_exterior( RID p_instance, bool p_enabled );
+	BIND2(instance_set_exterior, RID, bool  )
-	virtual void instance_set_room( RID p_instance, RID p_room );
+	BIND2(instance_set_room, RID, RID  )
 
-	virtual void instance_set_extra_visibility_margin( RID p_instance, real_t p_margin );
+	BIND2(instance_set_extra_visibility_margin, RID, real_t  )
 
 	// don't use these in a game!
-	virtual Vector<ObjectID> instances_cull_aabb(const AABB& p_aabb, RID p_scenario=RID()) const;
+	BIND2RC(Vector<ObjectID>,instances_cull_aabb,const AABB& , RID)
-	virtual Vector<ObjectID> instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario=RID()) const;
+	BIND3RC(Vector<ObjectID>,instances_cull_ray,const Vector3& , const Vector3& , RID )
-	virtual Vector<ObjectID> instances_cull_convex(const Vector<Plane>& p_convex, RID p_scenario=RID()) const;
+	BIND2RC(Vector<ObjectID>,instances_cull_convex,const Vector<Plane>& , RID)
 
 
-	virtual void instance_geometry_set_flag(RID p_instance,InstanceFlags p_flags,bool p_enabled);
+	BIND3(instance_geometry_set_flag,RID,InstanceFlags ,bool )
-	virtual void instance_geometry_set_cast_shadows_setting(RID p_instance, ShadowCastingSetting p_shadow_casting_setting);
+	BIND2(instance_geometry_set_cast_shadows_setting,RID, ShadowCastingSetting )
-	virtual void instance_geometry_set_material_override(RID p_instance, RID p_material);
+	BIND2(instance_geometry_set_material_override,RID, RID )
 
 
-	virtual void instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max,float p_min_margin,float p_max_margin);
+	BIND5(instance_geometry_set_draw_range,RID,float ,float ,float ,float )
-	virtual void instance_geometry_set_as_instance_lod(RID p_instance,RID p_as_lod_of_instance);
+	BIND2(instance_geometry_set_as_instance_lod,RID,RID )
 
 
 #undef BINDBASE
@@ -1055,6 +1065,7 @@ public:
 #undef BIND6
 #undef BIND7
 #undef BIND8
+#undef BIND9
 #undef BIND10
 
 };

servers/visual/visual_server_scene.h

@@ -0,0 +1,390 @@
+#ifndef VISUALSERVERSCENE_H
+#define VISUALSERVERSCENE_H
+
+#include "servers/visual/rasterizer.h"
+
+#include "geometry.h"
+#include "allocators.h"
+#include "octree.h"
+#include "self_list.h"
+
+class VisualServerScene {
+public:
+
+
+	enum {
+
+		MAX_INSTANCE_CULL=65536,
+		MAX_LIGHTS_CULLED=4096,
+		MAX_ROOM_CULL=32,
+		MAX_EXTERIOR_PORTALS=128,
+	};
+
+	uint64_t render_pass;
+
+
+	static VisualServerScene *singleton;
+#if 0
+	struct Portal {
+
+		bool enabled;
+		float disable_distance;
+		Color disable_color;
+		float connect_range;
+		Vector<Point2> shape;
+		Rect2 bounds;
+
+
+		Portal() { enabled=true; disable_distance=50; disable_color=Color(); connect_range=0.8; }
+	};
+
+	struct BakedLight {
+
+		Rasterizer::BakedLightData data;
+		DVector<int> sampler;
+		AABB octree_aabb;
+		Size2i octree_tex_size;
+		Size2i light_tex_size;
+
+	};
+
+	struct BakedLightSampler {
+
+		float params[BAKED_LIGHT_SAMPLER_MAX];
+		int resolution;
+		Vector<Vector3> dp_cache;
+
+		BakedLightSampler() {
+			params[BAKED_LIGHT_SAMPLER_STRENGTH]=1.0;
+			params[BAKED_LIGHT_SAMPLER_ATTENUATION]=1.0;
+			params[BAKED_LIGHT_SAMPLER_RADIUS]=1.0;
+			params[BAKED_LIGHT_SAMPLER_DETAIL_RATIO]=0.1;
+			resolution=16;
+		}
+	};
+
+	void _update_baked_light_sampler_dp_cache(BakedLightSampler * blsamp);
+
+#endif
+
+
+	struct Camera  : public RID_Data {
+
+		enum Type {
+			PERSPECTIVE,
+			ORTHOGONAL
+		};
+		Type type;
+		float fov;
+		float znear,zfar;
+		float size;
+		uint32_t visible_layers;
+		bool vaspect;
+		RID env;
+
+		Transform transform;
+
+		Camera() {
+
+			visible_layers=0xFFFFFFFF;
+			fov=60;
+			type=PERSPECTIVE;
+			znear=0.1; zfar=100;
+			size=1.0;
+			vaspect=false;
+
+		}
+	};
+
+	mutable RID_Owner<Camera> camera_owner;
+
+	virtual RID camera_create();
+	virtual void camera_set_perspective(RID p_camera,float p_fovy_degrees, float p_z_near, float p_z_far);
+	virtual void camera_set_orthogonal(RID p_camera,float p_size, float p_z_near, float p_z_far);
+	virtual void camera_set_transform(RID p_camera,const Transform& p_transform);
+	virtual void camera_set_cull_mask(RID p_camera,uint32_t p_layers);
+	virtual void camera_set_environment(RID p_camera,RID p_env);
+	virtual void camera_set_use_vertical_aspect(RID p_camera,bool p_enable);
+
+
+	/*
+
+	struct RoomInfo {
+
+		Transform affine_inverse;
+		Room *room;
+		List<Instance*> owned_geometry_instances;
+		List<Instance*> owned_portal_instances;
+		List<Instance*> owned_room_instances;
+		List<Instance*> owned_light_instances; //not used, but just for the sake of it
+		Set<Instance*> disconnected_child_portals;
+		Set<Instance*> owned_autoroom_geometry;
+		uint64_t last_visited_pass;
+		RoomInfo() { last_visited_pass=0; }
+
+	};
+
+	struct InstancePortal {
+
+		Portal *portal;
+		Set<Instance*> candidate_set;
+		Instance *connected;
+		uint64_t last_visited_pass;
+
+		Plane plane_cache;
+		Vector<Vector3> transformed_point_cache;
+
+
+		PortalInfo() { connected=NULL; last_visited_pass=0;}
+	};
+*/
+
+	/* ENVIRONMENT API */
+
+	virtual RID environment_create();
+
+	virtual void environment_set_background(RID p_env,VS::EnvironmentBG p_bg);
+	virtual void environment_set_skybox(RID p_env,RID p_skybox,float p_energy=1.0);
+	virtual void environment_set_bg_color(RID p_env,const Color& p_color);
+	virtual void environment_set_canvas_max_layer(RID p_env,int p_max_layer);
+	virtual void environment_set_ambient_light(RID p_env,const Color& p_color,float p_energy=1.0);
+
+	virtual void environment_set_glow(RID p_env,bool p_enable,int p_radius,float p_intensity,float p_strength,float p_bloom_treshold,VS::EnvironmentGlowBlendMode p_blend_mode);
+	virtual void environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture);
+
+	virtual void environment_set_tonemap(RID p_env,bool p_enable,float p_exposure,float p_white,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,VS::EnvironmentToneMapper p_tone_mapper);
+	virtual void environment_set_brightness(RID p_env,bool p_enable,float p_brightness);
+	virtual void environment_set_contrast(RID p_env,bool p_enable,float p_contrast);
+	virtual void environment_set_saturation(RID p_env,bool p_enable,float p_saturation);
+	virtual void environment_set_color_correction(RID p_env,bool p_enable,RID p_ramp);
+
+
+	/* SCENARIO API */
+
+	struct Instance;
+
+	struct Scenario  : RID_Data {
+
+
+		VS::ScenarioDebugMode debug;
+		RID self;
+		// well wtf, balloon allocator is slower?
+
+		Octree<Instance,true> octree;
+
+		List<Instance*> directional_lights;
+		RID environment;
+		RID fallback_environment;
+
+		SelfList<Instance>::List instances;
+
+		Scenario() {  debug=VS::SCENARIO_DEBUG_DISABLED; }
+	};
+
+	RID_Owner<Scenario> scenario_owner;
+
+	static void* _instance_pair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int);
+	static void _instance_unpair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int,void*);
+
+	virtual RID scenario_create();
+
+	virtual void scenario_set_debug(RID p_scenario,VS::ScenarioDebugMode p_debug_mode);
+	virtual void scenario_set_environment(RID p_scenario, RID p_environment);
+	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
+
+
+	/* INSTANCING API */
+
+	struct InstanceBaseData {
+
+
+		virtual ~InstanceBaseData() {}
+	};
+
+
+
+	struct Instance : RasterizerScene::InstanceBase {
+
+		RID self;
+		//scenario stuff
+		OctreeElementID octree_id;
+		Scenario *scenario;
+		SelfList<Instance> scenario_item;
+
+		//aabb stuff
+		bool update_aabb;
+		bool update_materials;
+		SelfList<Instance> update_item;
+
+
+		AABB aabb;
+		AABB transformed_aabb;
+		float extra_margin;
+		uint32_t object_ID;
+		bool visible;
+		uint32_t layer_mask;
+
+		float lod_begin;
+		float lod_end;
+		float lod_begin_hysteresis;
+		float lod_end_hysteresis;
+		RID lod_instance;
+
+		Instance *room;
+		SelfList<Instance> room_item;
+		bool visible_in_all_rooms;
+
+		uint64_t last_render_pass;
+		uint64_t last_frame_pass;
+
+		uint64_t version; // changes to this, and changes to base increase version
+
+		InstanceBaseData *base_data;
+
+		virtual void base_removed() {
+
+			singleton->instance_set_base(self,RID());
+		}
+
+		virtual void base_changed() {
+
+			singleton->_instance_queue_update(this,true,true);
+		}
+
+
+		Instance() : scenario_item(this), update_item(this), room_item(this) {
+
+			octree_id=0;
+			scenario=NULL;
+
+
+			update_aabb=false;
+			update_materials=false;
+
+			extra_margin=0;
+
+
+			object_ID=0;
+			visible=true;
+			layer_mask=1;
+
+			lod_begin=0;
+			lod_end=0;
+			lod_begin_hysteresis=0;
+			lod_end_hysteresis=0;
+
+			room=NULL;
+			visible_in_all_rooms=false;
+
+
+
+			last_render_pass=0;
+			last_frame_pass=0;
+			version=1;
+			base_data=NULL;
+
+		}
+
+		~Instance() {
+
+			if (base_data)
+				memdelete(base_data);
+
+		}
+	};
+
+	SelfList<Instance>::List _instance_update_list;
+	void _instance_queue_update(Instance *p_instance,bool p_update_aabb,bool p_update_materials=false);
+
+
+	struct InstanceGeometryData : public InstanceBaseData {
+
+		List<Instance*> lighting;
+		bool lighting_dirty;
+
+		InstanceGeometryData() {
+
+			lighting_dirty=false;
+		}
+	};
+
+
+	struct InstanceLightData : public InstanceBaseData {
+
+		struct PairInfo {
+			List<Instance*>::Element *L; //light iterator in geometry
+			Instance *geometry;
+		};
+
+		RID instance;
+		uint64_t last_hash;
+		List<Instance*>::Element *D; // directional light in scenario
+
+		bool shadow_sirty;
+
+		List<PairInfo> geometries;
+
+		InstanceLightData() {
+
+			shadow_sirty=true;
+			D=NULL;
+			last_hash=0;
+		}
+	};
+
+
+	Instance *instance_cull_result[MAX_INSTANCE_CULL];
+	Instance *instance_shadow_cull_result[MAX_INSTANCE_CULL]; //used for generating shadowmaps
+	Instance *light_cull_result[MAX_LIGHTS_CULLED];
+	RID light_instance_cull_result[MAX_LIGHTS_CULLED];
+	int light_cull_count;
+
+
+	RID_Owner<Instance> instance_owner;
+
+ // from can be mesh, light,  area and portal so far.
+	virtual RID instance_create(); // from can be mesh, light, poly, area and portal so far.
+
+	virtual void instance_set_base(RID p_instance, RID p_base); // from can be mesh, light, poly, area and portal so far.
+	virtual void instance_set_scenario(RID p_instance, RID p_scenario); // from can be mesh, light, poly, area and portal so far.
+	virtual void instance_set_layer_mask(RID p_instance, uint32_t p_mask);
+	virtual void instance_set_transform(RID p_instance, const Transform& p_transform);
+	virtual void instance_attach_object_instance_ID(RID p_instance,ObjectID p_ID);
+	virtual void instance_set_morph_target_weight(RID p_instance,int p_shape, float p_weight);
+	virtual void instance_set_surface_material(RID p_instance,int p_surface, RID p_material);
+
+	virtual void instance_attach_skeleton(RID p_instance,RID p_skeleton);
+	virtual void instance_set_exterior( RID p_instance, bool p_enabled );
+	virtual void instance_set_room( RID p_instance, RID p_room );
+
+	virtual void instance_set_extra_visibility_margin( RID p_instance, real_t p_margin );
+
+
+	// don't use these in a game!
+	virtual Vector<ObjectID> instances_cull_aabb(const AABB& p_aabb, RID p_scenario=RID()) const;
+	virtual Vector<ObjectID> instances_cull_ray(const Vector3& p_from, const Vector3& p_to, RID p_scenario=RID()) const;
+	virtual Vector<ObjectID> instances_cull_convex(const Vector<Plane>& p_convex, RID p_scenario=RID()) const;
+
+
+	virtual void instance_geometry_set_flag(RID p_instance,VS::InstanceFlags p_flags,bool p_enabled);
+	virtual void instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting);
+	virtual void instance_geometry_set_material_override(RID p_instance, RID p_material);
+
+
+	virtual void instance_geometry_set_draw_range(RID p_instance,float p_min,float p_max,float p_min_margin,float p_max_margin);
+	virtual void instance_geometry_set_as_instance_lod(RID p_instance,RID p_as_lod_of_instance);
+
+
+	_FORCE_INLINE_ void _update_instance(Instance *p_instance);
+	_FORCE_INLINE_ void _update_instance_aabb(Instance *p_instance);
+	_FORCE_INLINE_ void _update_dirty_instance(Instance *p_instance);
+
+
+	void render_camera(RID p_camera, RID p_scenario, Size2 p_viewport_size);
+	void update_dirty_instances();
+	bool free(RID p_rid);
+
+	VisualServerScene();
+};
+
+#endif // VISUALSERVERSCENE_H

servers/visual/visual_server_viewport.cpp

@@ -1,8 +1,11 @@
 #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 */
@@ -58,6 +61,12 @@ void VisualServerViewport::_draw_viewport(Viewport *p_viewport) {
 		}
 	}
 
+
+	if (!p_viewport->disable_3d && p_viewport->camera.is_valid()) {
+
+		VSG::scene->render_camera(p_viewport->camera,p_viewport->scenario,p_viewport->size);
+	}
+
 	if (!p_viewport->hide_canvas) {
 		int i=0;
 
@@ -248,6 +257,11 @@ void VisualServerViewport::draw_viewports() {
 
 		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);
 

servers/visual_server.cpp

@@ -345,8 +345,754 @@ RID VisualServer::get_white_texture() {
 }
 
 
+Error VisualServer::_surface_set_data(Array p_arrays,uint32_t p_format,uint32_t *p_offsets,uint32_t p_stride,DVector<uint8_t> &r_vertex_array,int p_vertex_array_len,DVector<uint8_t> &r_index_array,int p_index_array_len,AABB &r_aabb,Vector<AABB> r_bone_aabb) {
+
+	DVector<uint8_t>::Write vw = r_vertex_array.write();
+
+	DVector<uint8_t>::Write iw;
+	if (r_index_array.size()) {
+		iw=r_index_array.write();
+	}
+
+	int max_bone=0;
+
+
+	for(int ai=0;ai<VS::ARRAY_MAX;ai++) {
+
+		if (!(p_format&(1<<ai))) // no array
+			continue;
+
+
+		switch(ai) {
+
+			case VS::ARRAY_VERTEX: {
+
+				if (p_format& VS::ARRAY_FLAG_USE_2D_VERTICES) {
+
+					DVector<Vector2> array = p_arrays[ai];
+					ERR_FAIL_COND_V( array.size() != p_vertex_array_len, ERR_INVALID_PARAMETER );
+
+
+					DVector<Vector2>::Read read = array.read();
+					const Vector2* src=read.ptr();
+
+					// setting vertices means regenerating the AABB
+					Rect2 aabb;
+
+
+					if (p_format&ARRAY_COMPRESS_VERTEX) {
+
+						for (int i=0;i<p_vertex_array_len;i++) {
+
+
+							uint16_t vector[2]={ Math::make_half_float(src[i].x), Math::make_half_float(src[i].y) };
+
+							copymem(&vw[p_offsets[ai]+i*p_stride], vector, sizeof(uint16_t)*2);
+
+							if (i==0) {
+
+								aabb=Rect2(src[i],Vector2());
+							} else {
+
+								aabb.expand_to( src[i] );
+							}
+						}
+
+
+					} else {
+						for (int i=0;i<p_vertex_array_len;i++) {
+
+
+							float vector[2]={ src[i].x, src[i].y };
+
+							copymem(&vw[p_offsets[ai]+i*p_stride], vector, sizeof(float)*2);
+
+							if (i==0) {
+
+								aabb=Rect2(src[i],Vector2());
+							} else {
+
+								aabb.expand_to( src[i] );
+							}
+						}
+					}
+
+					r_aabb=AABB(Vector3(aabb.pos.x,aabb.pos.y,0),Vector3(aabb.size.x,aabb.size.y,0));
+
+
+				} else {
+					DVector<Vector3> array = p_arrays[ai];
+					ERR_FAIL_COND_V( array.size() != p_vertex_array_len, ERR_INVALID_PARAMETER );
+
+
+					DVector<Vector3>::Read read = array.read();
+					const Vector3* src=read.ptr();
+
+					// setting vertices means regenerating the AABB
+					AABB aabb;
+
+
+					if (p_format&ARRAY_COMPRESS_VERTEX) {
+
+						for (int i=0;i<p_vertex_array_len;i++) {
+
+
+							uint16_t vector[3]={ Math::make_half_float(src[i].x), Math::make_half_float(src[i].y), Math::make_half_float(src[i].z) };
+
+							copymem(&vw[p_offsets[ai]+i*p_stride], vector, sizeof(uint16_t)*3);
+
+							if (i==0) {
+
+								aabb=AABB(src[i],Vector3());
+							} else {
+
+								aabb.expand_to( src[i] );
+							}
+						}
+
+
+					} else {
+						for (int i=0;i<p_vertex_array_len;i++) {
+
+
+							float vector[3]={ src[i].x, src[i].y, src[i].z };
+
+							copymem(&vw[p_offsets[ai]+i*p_stride], vector, sizeof(float)*3);
+
+							if (i==0) {
+
+								aabb=AABB(src[i],Vector3());
+							} else {
+
+								aabb.expand_to( src[i] );
+							}
+						}
+					}
+
+					r_aabb=aabb;
+
+				}
+
+
+			} break;
+			case VS::ARRAY_NORMAL: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::VECTOR3_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<Vector3> array = p_arrays[ai];
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len, ERR_INVALID_PARAMETER );
+
+
+				DVector<Vector3>::Read read = array.read();
+				const Vector3* src=read.ptr();
+
+				// setting vertices means regenerating the AABB
+
+				if (p_format&ARRAY_COMPRESS_NORMAL) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint8_t vector[4]={
+							CLAMP(src[i].x*127,-128,127),
+							CLAMP(src[i].y*127,-128,127),
+							CLAMP(src[i].z*127,-128,127),
+							0,
+						};
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], vector, 4);
+
+					}
+
+				} else {
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+
+						float vector[3]={ src[i].x, src[i].y, src[i].z };
+						copymem(&vw[p_offsets[ai]+i*p_stride], vector, 3*4);
+
+					}
+				}
+
+			} break;
+
+			case VS::ARRAY_TANGENT: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::REAL_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<real_t> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len*4, ERR_INVALID_PARAMETER );
+
+
+				DVector<real_t>::Read read = array.read();
+				const real_t* src = read.ptr();
+
+				if (p_format&ARRAY_COMPRESS_TANGENT) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint8_t xyzw[4]={
+							CLAMP(src[i*4+0]*127,-128,127),
+							CLAMP(src[i*4+1]*127,-128,127),
+							CLAMP(src[i*4+2]*127,-128,127),
+							CLAMP(src[i*4+3]*127,-128,127)
+						};
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], xyzw, 4);
+
+					}
+
+
+				} else {
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						float xyzw[4]={
+							src[i*4+0],
+							src[i*4+1],
+							src[i*4+2],
+							src[i*4+3]
+						};
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], xyzw, 4*4);
+
+					}
+				}
+
+			} break;
+			case VS::ARRAY_COLOR: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::COLOR_ARRAY, ERR_INVALID_PARAMETER );
+
+
+				DVector<Color> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len, ERR_INVALID_PARAMETER );
+
+
+				DVector<Color>::Read read = array.read();
+				const Color* src = read.ptr();
+
+				if (p_format&ARRAY_COMPRESS_COLOR) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+
+						uint8_t colors[4];
+
+						for(int j=0;j<4;j++) {
+
+							colors[j]=CLAMP( int((src[i][j])*255.0), 0,255 );
+						}
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], colors, 4);
+
+					}
+				} else {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], &src[i], 4*4);
+					}
+
+				}
+
+
+			} break;
+			case VS::ARRAY_TEX_UV: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::VECTOR3_ARRAY && p_arrays[ai].get_type() != Variant::VECTOR2_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<Vector2> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len , ERR_INVALID_PARAMETER);
+
+				DVector<Vector2>::Read read = array.read();
+
+				const Vector2 * src=read.ptr();
+
+
+
+				if (p_format&ARRAY_COMPRESS_TEX_UV) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint16_t uv[2]={ Math::make_half_float(src[i].x) , Math::make_half_float(src[i].y) };
+						copymem(&vw[p_offsets[ai]+i*p_stride], uv, 2*2);
+					}
+
+				} else {
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						float uv[2]={ src[i].x , src[i].y };
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], uv, 2*4);
+
+					}
+				}
+
+
+			} break;
+
+			case VS::ARRAY_TEX_UV2: {
+
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::VECTOR3_ARRAY && p_arrays[ai].get_type() != Variant::VECTOR2_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<Vector2> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len , ERR_INVALID_PARAMETER);
+
+				DVector<Vector2>::Read read = array.read();
+
+				const Vector2 * src=read.ptr();
+
+
+
+				if (p_format&ARRAY_COMPRESS_TEX_UV2) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint16_t uv[2]={ Math::make_half_float(src[i].x) , Math::make_half_float(src[i].y) };
+						copymem(&vw[p_offsets[ai]+i*p_stride], uv, 2*2);
+					}
+
+				} else {
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						float uv[2]={ src[i].x , src[i].y };
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], uv, 2*4);
+
+					}
+				}
+			} break;
+			case VS::ARRAY_WEIGHTS: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::REAL_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<real_t> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len*VS::ARRAY_WEIGHTS_SIZE, ERR_INVALID_PARAMETER );
+
+
+				DVector<real_t>::Read read = array.read();
+
+				const real_t * src = read.ptr();
+
+				if (p_format&ARRAY_COMPRESS_WEIGHTS) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint16_t data[VS::ARRAY_WEIGHTS_SIZE];
+						for (int j=0;j<VS::ARRAY_WEIGHTS_SIZE;j++) {
+							data[j]=CLAMP(src[i*VS::ARRAY_WEIGHTS_SIZE+j]*65535,0,65535);
+						}
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], data, 2*4);
+					}
+				} else {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						float data[VS::ARRAY_WEIGHTS_SIZE];
+						for (int j=0;j<VS::ARRAY_WEIGHTS_SIZE;j++) {
+							data[j]=src[i*VS::ARRAY_WEIGHTS_SIZE+j];
+						}
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], data, 4*4);
+
+
+					}
+				}
+
+			} break;
+			case VS::ARRAY_BONES: {
+
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::REAL_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<int> array = p_arrays[ai];
+
+				ERR_FAIL_COND_V( array.size() != p_vertex_array_len*VS::ARRAY_WEIGHTS_SIZE, ERR_INVALID_PARAMETER );
+
+
+				DVector<int>::Read read = array.read();
+
+				const int * src = read.ptr();
+
+
+				if (!(p_format&ARRAY_FLAG_USE_16_BIT_BONES)) {
+
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint8_t data[VS::ARRAY_WEIGHTS_SIZE];
+						for (int j=0;j<VS::ARRAY_WEIGHTS_SIZE;j++) {
+							data[j]=CLAMP(src[i*VS::ARRAY_WEIGHTS_SIZE+j],0,255);
+							max_bone=MAX(data[j],max_bone);
+
+						}
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], data, 4);
+
+
+					}
+
+				} else {
+					for (int i=0;i<p_vertex_array_len;i++) {
+
+						uint16_t data[VS::ARRAY_WEIGHTS_SIZE];
+						for (int j=0;j<VS::ARRAY_WEIGHTS_SIZE;j++) {
+							data[j]=src[i*VS::ARRAY_WEIGHTS_SIZE+j];
+							max_bone=MAX(data[j],max_bone);
+
+						}
+
+						copymem(&vw[p_offsets[ai]+i*p_stride], data, 2*4);
+
+
+					}
+				}
+
+
+			} break;
+			case VS::ARRAY_INDEX: {
+
+
+				ERR_FAIL_COND_V( p_index_array_len<=0, ERR_INVALID_DATA );
+				ERR_FAIL_COND_V( p_arrays[ai].get_type() != Variant::INT_ARRAY, ERR_INVALID_PARAMETER );
+
+				DVector<int> indices = p_arrays[ai];
+				ERR_FAIL_COND_V( indices.size() == 0, ERR_INVALID_PARAMETER );
+				ERR_FAIL_COND_V( indices.size() != p_index_array_len, ERR_INVALID_PARAMETER );
+
+				/* determine wether using 16 or 32 bits indices */
+
+				DVector<int>::Read read = indices.read();
+				const int *src=read.ptr();
+
+				for (int i=0;i<p_index_array_len;i++) {
+
+
+					if (p_vertex_array_len<(1<<16)) {
+						uint16_t v=src[i];
+
+						copymem(&iw[i*2], &v, 2);
+					} else {
+						uint32_t v=src[i];
+
+						copymem(&iw[i*4], &v, 4);
+					}
+				}
+			} break;
+			default: {
+				ERR_FAIL_V( ERR_INVALID_DATA );
+			}
+		}
+	}
+
+
+	if (p_format&VS::ARRAY_FORMAT_BONES) {
+		//create AABBs for each detected bone
+		int total_bones = max_bone+1;
+
+		bool first = r_bone_aabb.size()==0;
+
+		r_bone_aabb.resize(total_bones);
+
+		if (first) {
+			for(int i=0;i<total_bones;i++) {
+				r_bone_aabb[i].size==Vector3(-1,-1,-1); //negative means unused
+			}
+		}
+
+		DVector<Vector3> vertices = p_arrays[VS::ARRAY_VERTEX];
+		DVector<int> bones = p_arrays[VS::ARRAY_BONES];
+		DVector<float> weights = p_arrays[VS::ARRAY_WEIGHTS];
+
+		bool any_valid=false;
+
+		if (vertices.size() && bones.size()==vertices.size()*4 && weights.size()==bones.size()) {
+
+			int vs = vertices.size();
+			DVector<Vector3>::Read rv =vertices.read();
+			DVector<int>::Read rb=bones.read();
+			DVector<float>::Read rw=weights.read();
+
+			AABB *bptr = r_bone_aabb.ptr();
+
+			for(int i=0;i<vs;i++) {
+
+				Vector3 v = rv[i];
+				for(int j=0;j<4;j++) {
+
+					int idx = rb[i*4+j];
+					float w = rw[i*4+j];
+					if (w==0)
+						continue;//break;
+					ERR_FAIL_INDEX_V(idx,total_bones,ERR_INVALID_DATA);
+
+					if (bptr->size.x<0) {
+						//first
+						bptr[idx]=AABB();
+						bptr[idx].pos=v;
+						any_valid=true;
+					} else {
+						bptr[idx].expand_to(v);
+					}
+				}
+			}
+		}
+
+		if (!any_valid && first) {
+
+			r_bone_aabb.clear();
+		}
+	}
+	return OK;
+}
+
+
 void VisualServer::mesh_add_surface_from_arrays(RID p_mesh,PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes,uint32_t p_compress_format) {
 
+	ERR_FAIL_INDEX( p_primitive, VS::PRIMITIVE_MAX );
+	ERR_FAIL_COND(p_arrays.size()!=VS::ARRAY_MAX);
+
+	uint32_t format=0;
+
+	// validation
+	int index_array_len=0;
+	int array_len=0;
+
+	for(int i=0;i<p_arrays.size();i++) {
+
+		if (p_arrays[i].get_type()==Variant::NIL)
+			continue;
+
+		format|=(1<<i);
+
+		if (i==VS::ARRAY_VERTEX) {
+
+			Variant var = p_arrays[i];
+			switch(var.get_type()) {
+				case Variant::VECTOR2_ARRAY: {
+					DVector<Vector2> v2 = var;
+					array_len=v2.size();
+				} break;
+				case Variant::VECTOR3_ARRAY: {
+					DVector<Vector3> v3 = var;
+					array_len=v3.size();
+				} break;
+				default: {
+					Array v = var;
+					array_len=v.size();
+				} break;
+			}
+
+			array_len=Vector3Array(p_arrays[i]).size();
+			ERR_FAIL_COND(array_len==0);
+		} else if (i==VS::ARRAY_INDEX) {
+
+			index_array_len=IntArray(p_arrays[i]).size();
+		}
+	}
+
+	ERR_FAIL_COND((format&VS::ARRAY_FORMAT_VERTEX)==0); // mandatory
+
+
+	if (p_blend_shapes.size()) {
+		//validate format for morphs
+		for(int i=0;i<p_blend_shapes.size();i++) {
+
+			uint32_t bsformat=0;
+			Array arr = p_blend_shapes[i];
+			for(int j=0;j<arr.size();j++) {
+
+
+				if (arr[j].get_type()!=Variant::NIL)
+					bsformat|=(1<<j);
+			}
+
+			ERR_FAIL_COND( (bsformat)!=(format&(VS::ARRAY_FORMAT_BONES-1)));
+		}
+	}
+
+	uint32_t offsets[VS::ARRAY_MAX];
+
+	int total_elem_size=0;
+
+	for (int i=0;i<VS::ARRAY_MAX;i++) {
+
+
+		offsets[i]=0; //reset
+
+		if (!(format&(1<<i))) // no array
+			continue;
+
+
+		int elem_size=0;
+
+		switch(i) {
+
+			case VS::ARRAY_VERTEX: {
+
+				Variant arr = p_arrays[0];
+				if (arr.get_type()==Variant::VECTOR2_ARRAY) {
+					elem_size=2;
+					p_compress_format|=ARRAY_FLAG_USE_2D_VERTICES;
+				} else if (arr.get_type()==Variant::VECTOR3_ARRAY) {
+					p_compress_format&=~ARRAY_FLAG_USE_2D_VERTICES;
+					elem_size=3;
+				} else {
+					elem_size=(p_compress_format&ARRAY_FLAG_USE_2D_VERTICES)?2:3;
+				}
+
+				if (p_compress_format&ARRAY_COMPRESS_VERTEX) {
+					elem_size*=sizeof(int16_t);
+				} else {
+					elem_size*=sizeof(float);
+				}
+
+			} break;
+			case VS::ARRAY_NORMAL: {
+
+				if (p_compress_format&ARRAY_COMPRESS_NORMAL) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(float)*3;
+				}
+
+			} break;
+
+			case VS::ARRAY_TANGENT: {
+				if (p_compress_format&ARRAY_COMPRESS_TANGENT) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(float)*4;
+				}
+
+			} break;
+			case VS::ARRAY_COLOR: {
+
+				if (p_compress_format&ARRAY_COMPRESS_COLOR) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(float)*4;
+				}
+			} break;
+			case VS::ARRAY_TEX_UV: {
+				if (p_compress_format&ARRAY_COMPRESS_TEX_UV) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(float)*2;
+				}
+
+			} break;
+
+			case VS::ARRAY_TEX_UV2: {
+				if (p_compress_format&ARRAY_COMPRESS_TEX_UV2) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(float)*2;
+				}
+
+			} break;
+			case VS::ARRAY_WEIGHTS: {
+
+				if (p_compress_format&ARRAY_COMPRESS_WEIGHTS) {
+					elem_size=sizeof(uint16_t)*4;
+				} else {
+					elem_size=sizeof(float)*4;
+				}
+
+			} break;
+			case VS::ARRAY_BONES: {
+
+				if (p_compress_format&ARRAY_FLAG_USE_16_BIT_BONES) {
+					elem_size=sizeof(uint32_t);
+				} else {
+					elem_size=sizeof(uint16_t)*4;
+				}
+
+			} break;
+			case VS::ARRAY_INDEX: {
+
+				if (index_array_len<=0) {
+					ERR_PRINT("index_array_len==NO_INDEX_ARRAY");
+					break;
+				}
+				/* determine wether using 16 or 32 bits indices */
+				if (array_len>(1<<16)) {
+
+					elem_size=4;
+
+				} else {
+					elem_size=2;
+				}
+				offsets[i]=elem_size;
+				continue;
+			} break;
+			default: {
+				ERR_FAIL( );
+			}
+		}
+
+		print_line("type "+itos(i)+" size: "+itos(elem_size)+" offset "+itos(total_elem_size));
+		offsets[i]=total_elem_size;
+		total_elem_size+=elem_size;
+
+
+	}
+
+	print_line("total elemn size: "+itos(total_elem_size));
+
+	uint32_t mask = (1<<ARRAY_MAX)-1;
+	format|=~mask&p_compress_format; //make the full format
+
+
+	int array_size = total_elem_size * array_len;
+
+	print_line("array size: "+itos(array_size));
+
+	DVector<uint8_t> vertex_array;
+	vertex_array.resize(array_size);
+
+	int index_array_size = offsets[VS::ARRAY_INDEX]*index_array_len;
+
+	print_line("index array size: "+itos(index_array_size));
+
+	DVector<uint8_t> index_array;
+	index_array.resize(index_array_size);
+
+	AABB aabb;
+	Vector<AABB> bone_aabb;
+
+	Error err = _surface_set_data(p_arrays,format,offsets,total_elem_size,vertex_array,array_len,index_array,index_array_len,aabb,bone_aabb);
+
+	if (err) {
+		ERR_EXPLAIN("Invalid array format for surface");
+		ERR_FAIL_COND(err!=OK);
+	}
+
+	Vector<DVector<uint8_t> > blend_shape_data;
+
+	for(int i=0;i<p_blend_shapes.size();i++) {
+
+		DVector<uint8_t> vertex_array_shape;
+		vertex_array_shape.resize(array_size);
+		DVector<uint8_t> noindex;
+
+		AABB laabb;
+		Error err = _surface_set_data(p_blend_shapes[i],format&~ARRAY_FORMAT_INDEX,offsets,total_elem_size,vertex_array,array_len,noindex,0,laabb,bone_aabb);
+		aabb.merge_with(laabb);
+		if (err) {
+			ERR_EXPLAIN("Invalid blend shape array format for surface");
+			ERR_FAIL_COND(err!=OK);
+		}
+
+		blend_shape_data.push_back(vertex_array_shape);
+	}
+
+	mesh_add_surface(p_mesh,format,p_primitive,vertex_array,array_len,index_array,index_array_len,aabb,blend_shape_data,bone_aabb);
 
 }
 

servers/visual_server.h

@@ -59,6 +59,9 @@ protected:
 	RID test_material;
 	RID material_2d[16];
 
+
+	Error _surface_set_data(Array p_arrays,uint32_t p_format,uint32_t *p_offsets,uint32_t p_stride,DVector<uint8_t> &r_vertex_array,int p_vertex_array_len,DVector<uint8_t> &r_index_array,int p_index_array_len,AABB &r_aabb,Vector<AABB> r_bone_aabb);
+
 	static VisualServer* (*create_func)();
 	static void _bind_methods();
 public:
@@ -207,6 +210,7 @@ public:
 		ARRAY_COMPRESS_INDEX=1<<(ARRAY_INDEX+ARRAY_COMPRESS_BASE),
 
 		ARRAY_FLAG_USE_2D_VERTICES=ARRAY_COMPRESS_INDEX<<1,
+		ARRAY_FLAG_USE_16_BIT_BONES=ARRAY_COMPRESS_INDEX<<2,
 
 		ARRAY_COMPRESS_DEFAULT=ARRAY_COMPRESS_VERTEX|ARRAY_COMPRESS_NORMAL|ARRAY_COMPRESS_TANGENT|ARRAY_COMPRESS_COLOR|ARRAY_COMPRESS_TEX_UV|ARRAY_COMPRESS_TEX_UV2|ARRAY_COMPRESS_BONES|ARRAY_COMPRESS_WEIGHTS|ARRAY_COMPRESS_INDEX
 
@@ -228,7 +232,7 @@ public:
 
 
 	virtual void mesh_add_surface_from_arrays(RID p_mesh,PrimitiveType p_primitive,const Array& p_arrays,const Array& p_blend_shapes=Array(),uint32_t p_compress_format=ARRAY_COMPRESS_DEFAULT);
-	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >())=0;
+	virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,PrimitiveType p_primitive,const DVector<uint8_t>& p_array,int p_vertex_count,const DVector<uint8_t>& p_index_array,int p_index_count,const AABB& p_aabb,const Vector<DVector<uint8_t> >& p_blend_shapes=Vector<DVector<uint8_t> >(),const Vector<AABB>& p_bone_aabbs=Vector<AABB>())=0;
 
 	virtual void mesh_set_morph_target_count(RID p_mesh,int p_amount)=0;
 	virtual int mesh_get_morph_target_count(RID p_mesh) const=0;
@@ -530,7 +534,6 @@ public:
 
 	virtual void scenario_set_debug(RID p_scenario,ScenarioDebugMode p_debug_mode)=0;
 	virtual void scenario_set_environment(RID p_scenario, RID p_environment)=0;
-	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const=0;
 	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment)=0;
 
 
@@ -546,6 +549,7 @@ public:
 		INSTANCE_REFLECTION_PROBE,
 		INSTANCE_ROOM,
 		INSTANCE_PORTAL,
+		INSTANCE_MAX,
 		/*INSTANCE_BAKED_LIGHT,
 		INSTANCE_BAKED_LIGHT_SAMPLER,*/
 

tools/editor/plugins/spatial_editor_plugin.cpp

@@ -2349,6 +2349,7 @@ SpatialEditorViewport::SpatialEditorViewport(SpatialEditor *p_spatial_editor, Ed
 
 	spatial_editor=p_spatial_editor;
 	ViewportContainer *c=memnew(ViewportContainer);
+	c->set_stretch(true);
 	add_child(c);
 	c->set_area_as_parent_rect();
 	viewport = memnew( Viewport );