can bake for omni and spotlight

store normal when baking

6 files changed, 100 insertions, 31 deletions

diff --git a/drivers/gles3/rasterizer_gles3.cpp b/drivers/gles3/rasterizer_gles3.cpp
index cb42790e67..bf3b902c5c 100644
--- a/drivers/gles3/rasterizer_gles3.cpp
+++ b/drivers/gles3/rasterizer_gles3.cpp
@@ -130,9 +130,9 @@ void RasterizerGLES3::initialize() {
 		ERR_PRINT("Error initializing GLAD");
 	}
 
-//	glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
-//	glDebugMessageCallbackARB(_gl_debug_print, NULL);
-//	glEnable(_EXT_DEBUG_OUTPUT);
+	glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+	glDebugMessageCallbackARB(_gl_debug_print, NULL);
+	glEnable(_EXT_DEBUG_OUTPUT);
 
 #endif
 
diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp
index 675b6f228d..1a63d451b1 100644
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -100,6 +100,8 @@ void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
 
 		shadow_atlas->depth=0;
 		shadow_atlas->fbo=0;
+
+		print_line("erasing atlas");
 	}
 	for(int i=0;i<4;i++) {
 		//clear subdivisions
@@ -130,19 +132,18 @@ void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_atlas->size, shadow_atlas->size, 0,
 			     GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
 
-		//interpola nearest (though nvidia can improve this)
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-//		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-//		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		// Remove artifact on the edges of the shadowmap
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-		// We'll use a depth texture to store the depths in the shadow map
-		// Attach the depth texture to FBO depth attachment point
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
 				       GL_TEXTURE_2D, shadow_atlas->depth, 0);
+
+		glViewport(0,0,shadow_atlas->size,shadow_atlas->size);
+		glClearDepth(0);
+		glClear(GL_DEPTH_BUFFER_BIT);
+
 	}
 }
 
@@ -523,12 +524,19 @@ void RasterizerSceneGLES3::reflection_atlas_set_size(RID p_ref_atlas,int p_size)
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 5);
+
 		mmsize=reflection_atlas->size;
 
 		for(int i=0;i<6;i++) {
 			glGenFramebuffers(1, &reflection_atlas->fbo[i]);
 			glBindFramebuffer(GL_FRAMEBUFFER, reflection_atlas->fbo[i]);
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,  reflection_atlas->color, i);
+
+			GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+			ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+
 			glDisable(GL_SCISSOR_TEST);
 			glViewport(0,0,mmsize,mmsize);
 			glClearColor(0,0,0,0);
@@ -538,8 +546,6 @@ void RasterizerSceneGLES3::reflection_atlas_set_size(RID p_ref_atlas,int p_size)
 
 		}
 
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 5);
 
 	}
 
@@ -1020,11 +1026,12 @@ RID RasterizerSceneGLES3::gi_probe_instance_create() {
 	return gi_probe_instance_owner.make_rid(gipi);
 }
 
-void RasterizerSceneGLES3::gi_probe_instance_set_light_data(RID p_probe,RID p_data) {
+void RasterizerSceneGLES3::gi_probe_instance_set_light_data(RID p_probe, RID p_base, RID p_data) {
 
 	GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
 	ERR_FAIL_COND(!gipi);
 	gipi->data=p_data;
+	gipi->probe=storage->gi_probe_owner.getornull(p_base);
 	if (p_data.is_valid()) {
 		RasterizerStorageGLES3::GIProbeData *gipd = storage->gi_probe_data_owner.getornull(p_data);
 		ERR_FAIL_COND(!gipd);
@@ -1571,6 +1578,8 @@ void RasterizerSceneGLES3::_setup_light(RenderList::Element *e,const Transform&
 		glBindTexture(GL_TEXTURE_3D,gipi->tex_cache);
 		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_XFORM1, gipi->transform_to_data * p_view_transform);
 		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BOUNDS1, gipi->bounds);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_MULTIPLIER1, gipi->probe?gipi->probe->dynamic_range*gipi->probe->energy:0.0);
+		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BLEND_AMBIENT1, gipi->probe?!gipi->probe->interior:false);
 		state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_CELL_SIZE1, gipi->cell_size_cache);
 		if (gi_probe_count>1) {
 
@@ -1581,7 +1590,8 @@ void RasterizerSceneGLES3::_setup_light(RenderList::Element *e,const Transform&
 			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_XFORM2, gipi2->transform_to_data * p_view_transform);
 			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BOUNDS2, gipi2->bounds);
 			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_CELL_SIZE2, gipi2->cell_size_cache);
-
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_MULTIPLIER2, gipi2->probe?gipi2->probe->dynamic_range*gipi2->probe->energy:0.0);
+			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BLEND_AMBIENT2, gipi2->probe?!gipi2->probe->interior:false);
 			state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE2_ENABLED, true );
 		} else {
 
@@ -4209,7 +4219,6 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
 		fbo=shadow_atlas->fbo;
 		vp_height=shadow_atlas->size;
 
-
 		uint32_t key = shadow_atlas->shadow_owners[p_light];
 
 		uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
@@ -4299,24 +4308,22 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
 	render_list.sort_by_depth(false); //shadow is front to back for performance
 
 	glDepthMask(true);
-	glColorMask(0,0,0,0);
+	glColorMask(1,1,1,1);
 	glDisable(GL_BLEND);
 	glDisable(GL_DITHER);
 	glEnable(GL_DEPTH_TEST);
-
 	glBindFramebuffer(GL_FRAMEBUFFER,fbo);
 
 	if (custom_vp_size) {
 		glViewport(0,0,custom_vp_size,custom_vp_size);
 		glScissor(0,0,custom_vp_size,custom_vp_size);
 
+
 	} else {
 		glViewport(x,y,width,height);
 		glScissor(x,y,width,height);
 	}
 
-	//glViewport(x,vp_height-(height+y),width,height);
-	//glScissor(x,vp_height-(height+y),width,height);
 	glEnable(GL_SCISSOR_TEST);
 	glClearDepth(1.0);
 	glClear(GL_DEPTH_BUFFER_BIT);
@@ -4331,7 +4338,7 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
 
 	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_SHADOW,true);
 
-	_render_list(render_list.elements,render_list.element_count,light_transform,light_projection,NULL,!flip_facing,false,true,false,false);
+	_render_list(render_list.elements,render_list.element_count,light_transform,light_projection,0,!flip_facing,false,true,false,false);
 
 	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_SHADOW,false);
 	state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_SHADOW_DUAL_PARABOLOID,false);
diff --git a/drivers/gles3/rasterizer_scene_gles3.h b/drivers/gles3/rasterizer_scene_gles3.h
index ce869da131..31d9964ab0 100644
--- a/drivers/gles3/rasterizer_scene_gles3.h
+++ b/drivers/gles3/rasterizer_scene_gles3.h
@@ -531,6 +531,7 @@ public:
 
 	struct GIProbeInstance : public RID_Data {
 		RID data;
+		RasterizerStorageGLES3::GIProbe *probe;
 		GLuint tex_cache;
 		Vector3 cell_size_cache;
 		Vector3 bounds;
@@ -542,7 +543,7 @@ public:
 	mutable RID_Owner<GIProbeInstance> gi_probe_instance_owner;
 
 	virtual RID gi_probe_instance_create();
-	virtual void gi_probe_instance_set_light_data(RID p_probe,RID p_data);
+	virtual void gi_probe_instance_set_light_data(RID p_probe,RID p_base,RID p_data);
 	virtual void gi_probe_instance_set_transform_to_data(RID p_probe,const Transform& p_xform);
 	virtual void gi_probe_instance_set_bounds(RID p_probe,const Vector3& p_bounds);
 
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp
index 9edc37fe3b..fe8373b20d 100644
--- a/drivers/gles3/rasterizer_storage_gles3.cpp
+++ b/drivers/gles3/rasterizer_storage_gles3.cpp
@@ -4695,6 +4695,8 @@ RID RasterizerStorageGLES3::gi_probe_create() {
 	gip->data_depth=0;
 	gip->bounds=AABB(Vector3(),Vector3(1,1,1));
 	gip->dynamic_range=1.0;
+	gip->energy=1.0;
+	gip->interior=false;
 	gip->version=1;
 	gip->cell_size=1.0;
 
@@ -4773,7 +4775,7 @@ DVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) cons
 	return gip->dynamic_data;
 }
 
-void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,float p_range){
+void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int p_range){
 
 	GIProbe *gip = gi_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!gip);
@@ -4781,7 +4783,7 @@ void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,float p_rang
 	gip->dynamic_range=p_range;
 
 }
-float RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
+int RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
 
 	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!gip,0);
@@ -4789,6 +4791,41 @@ float RasterizerStorageGLES3::gi_probe_get_dynamic_range(RID p_probe) const{
 	return gip->dynamic_range;
 }
 
+void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe,float p_range){
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->energy=p_range;
+
+}
+
+void RasterizerStorageGLES3::gi_probe_set_interior(RID p_probe,bool p_enable) {
+
+	GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!gip);
+
+	gip->interior=p_enable;
+
+}
+
+bool RasterizerStorageGLES3::gi_probe_is_interior(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,false);
+
+	return gip->interior;
+
+}
+
+float RasterizerStorageGLES3::gi_probe_get_energy(RID p_probe) const{
+
+	const GIProbe *gip = gi_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!gip,0);
+
+	return gip->energy;
+}
+
 
 void RasterizerStorageGLES3::gi_probe_set_static_data(RID p_gi_probe,const DVector<uint8_t>& p_data,VS::GIProbeDataFormat p_format,int p_width,int p_height,int p_depth) {
 
diff --git a/drivers/gles3/rasterizer_storage_gles3.h b/drivers/gles3/rasterizer_storage_gles3.h
index 5d07d0be87..c51cd8d90b 100644
--- a/drivers/gles3/rasterizer_storage_gles3.h
+++ b/drivers/gles3/rasterizer_storage_gles3.h
@@ -890,7 +890,9 @@ public:
 		Transform to_cell;
 		float cell_size;
 
-		float dynamic_range;
+		int dynamic_range;
+		float energy;
+		bool interior;
 
 		uint32_t version;
 
@@ -921,9 +923,14 @@ public:
 	virtual void gi_probe_set_dynamic_data(RID p_probe,const DVector<int>& p_data);
 	virtual DVector<int> gi_probe_get_dynamic_data(RID p_probe) const;
 
-	virtual void gi_probe_set_dynamic_range(RID p_probe,float p_range);
-	virtual float gi_probe_get_dynamic_range(RID p_probe) const;
+	virtual void gi_probe_set_dynamic_range(RID p_probe,int p_range);
+	virtual int gi_probe_get_dynamic_range(RID p_probe) const;
+
+	virtual void gi_probe_set_energy(RID p_probe,float p_range);
+	virtual float gi_probe_get_energy(RID p_probe) const;
 
+	virtual void gi_probe_set_interior(RID p_probe,bool p_enable);
+	virtual bool gi_probe_is_interior(RID p_probe) const;
 
 	virtual void gi_probe_set_static_data(RID p_gi_probe,const DVector<uint8_t>& p_data,VS::GIProbeDataFormat p_format,int p_width,int p_height,int p_depth);
 	virtual DVector<uint8_t> gi_probe_get_static_data(RID p_gi_probe) const;
diff --git a/drivers/gles3/shaders/scene.glsl b/drivers/gles3/shaders/scene.glsl
index c9de56be4f..2dfbbd340d 100644
--- a/drivers/gles3/shaders/scene.glsl
+++ b/drivers/gles3/shaders/scene.glsl
@@ -845,14 +845,18 @@ uniform mediump sampler3D gi_probe1; //texunit:-6
 uniform highp mat4 gi_probe_xform1;
 uniform highp vec3 gi_probe_bounds1;
 uniform highp vec3 gi_probe_cell_size1;
+uniform highp float gi_probe_multiplier1;
+uniform bool gi_probe_blend_ambient1;
 
 uniform mediump sampler3D gi_probe2; //texunit:-7
 uniform highp mat4 gi_probe_xform2;
 uniform highp vec3 gi_probe_bounds2;
 uniform highp vec3 gi_probe_cell_size2;
+uniform highp float gi_probe_multiplier2;
 uniform bool gi_probe2_enabled;
+uniform bool gi_probe_blend_ambient2;
 
-vec3 voxel_cone_trace(sampler3D probe, vec3 cell_size, vec3 pos, vec3 direction, float tan_half_angle, float max_distance) {
+vec3 voxel_cone_trace(sampler3D probe, vec3 cell_size, vec3 pos, vec3 ambient, bool blend_ambient, vec3 direction, float tan_half_angle, float max_distance) {
 
 
 	float dist = dot(direction,mix(vec3(-1.0),vec3(1.0),greaterThan(direction,vec3(0.0))))*2.0;
@@ -868,10 +872,12 @@ vec3 voxel_cone_trace(sampler3D probe, vec3 cell_size, vec3 pos, vec3 direction,
 		dist += diameter * 0.5;
 	}
 
+	color.rgb = mix(color.rgb,mix(ambient,color.rgb,alpha),blend_ambient);
+
 	return color.rgb;
 }
 
-void gi_probe_compute(sampler3D probe, mat4 probe_xform, vec3 bounds,vec3 cell_size,vec3 pos, mat3 normal_mtx,vec3 ref_vec, float roughness, out vec4 out_spec, out vec4 out_diff) {
+void gi_probe_compute(sampler3D probe, mat4 probe_xform, vec3 bounds,vec3 cell_size,vec3 pos, vec3 ambient, vec3 environment, bool blend_ambient,float multiplier, mat3 normal_mtx,vec3 ref_vec, float roughness, out vec4 out_spec, out vec4 out_diff) {
 
 
 
@@ -928,15 +934,19 @@ void gi_probe_compute(sampler3D probe, mat4 probe_xform, vec3 bounds,vec3 cell_s
 	for(int i=0;i<MAX_CONE_DIRS;i++) {
 
 		vec3 dir = normalize( (probe_xform * vec4(pos + normal_mtx * cone_dirs[i],1.0)).xyz - probe_pos);
-		light+=cone_weights[i] * voxel_cone_trace(probe,cell_size,probe_pos,dir,cone_angle_tan,max_distance);
+		light+=cone_weights[i] * voxel_cone_trace(probe,cell_size,probe_pos,ambient,blend_ambient,dir,cone_angle_tan,max_distance);
 
 	}
 
+	light*=multiplier;
+
 	out_diff = vec4(light*blend,blend);
 
 	//irradiance
 
-	vec3 irr_light =  voxel_cone_trace(probe,cell_size,probe_pos,ref_vec,tan(roughness * 0.5 * M_PI) ,max_distance);
+	vec3 irr_light =  voxel_cone_trace(probe,cell_size,probe_pos,environment,blend_ambient,ref_vec,tan(roughness * 0.5 * M_PI) ,max_distance);
+
+	irr_light *= multiplier;
 	//irr_light=vec3(0.0);
 
 	out_spec = vec4(irr_light*blend,blend);
@@ -958,11 +968,18 @@ void gi_probes_compute(vec3 pos, vec3 normal, float roughness, vec3 specular, in
 	vec4 diff_accum = vec4(0.0);
 	vec4 spec_accum = vec4(0.0);
 
-	gi_probe_compute(gi_probe1,gi_probe_xform1,gi_probe_bounds1,gi_probe_cell_size1,pos,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
+	vec3 ambient = out_ambient;
+	out_ambient = vec3(0.0);
+
+	vec3 environment = out_specular;
+
+	out_specular = vec3(0.0);
+
+	gi_probe_compute(gi_probe1,gi_probe_xform1,gi_probe_bounds1,gi_probe_cell_size1,pos,ambient,environment,gi_probe_blend_ambient1,gi_probe_multiplier1,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
 
 	if (gi_probe2_enabled) {
 
-		gi_probe_compute(gi_probe2,gi_probe_xform2,gi_probe_bounds2,gi_probe_cell_size2,pos,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
+		gi_probe_compute(gi_probe2,gi_probe_xform2,gi_probe_bounds2,gi_probe_cell_size2,pos,ambient,environment,gi_probe_blend_ambient2,gi_probe_multiplier2,normal_mat,ref_vec,roughness,spec_accum,diff_accum);
 	}
 
 	if (diff_accum.a>0.0) {