aboutsummaryrefslogtreecommitdiff
path: root/drivers/gles3
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gles3')
-rw-r--r--drivers/gles3/rasterizer_canvas_gles3.cpp1080
-rw-r--r--drivers/gles3/rasterizer_canvas_gles3.h28
-rw-r--r--drivers/gles3/rasterizer_gles3.cpp243
-rw-r--r--drivers/gles3/rasterizer_gles3.h11
-rw-r--r--drivers/gles3/rasterizer_scene_gles3.cpp3775
-rw-r--r--drivers/gles3/rasterizer_scene_gles3.h324
-rw-r--r--drivers/gles3/rasterizer_storage_gles3.cpp4874
-rw-r--r--drivers/gles3/rasterizer_storage_gles3.h547
-rw-r--r--drivers/gles3/shader_compiler_gles3.cpp611
-rw-r--r--drivers/gles3/shader_compiler_gles3.h29
-rw-r--r--drivers/gles3/shader_gles3.cpp622
-rw-r--r--drivers/gles3/shader_gles3.h289
12 files changed, 5666 insertions, 6767 deletions
diff --git a/drivers/gles3/rasterizer_canvas_gles3.cpp b/drivers/gles3/rasterizer_canvas_gles3.cpp
index 2526aad07..26d13bad8 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.cpp
+++ b/drivers/gles3/rasterizer_canvas_gles3.cpp
@@ -34,60 +34,58 @@
#define glClearDepth glClearDepthf
#endif
-static _FORCE_INLINE_ void store_transform2d(const Transform2D& p_mtx, float* p_array) {
+static _FORCE_INLINE_ void store_transform2d(const Transform2D &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;
+ 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_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) {
+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++) {
+ for (int i = 0; i < 4; i++) {
+ for (int j = 0; j < 4; j++) {
- p_array[i*4+j]=p_mtx.matrix[i][j];
+ p_array[i * 4 + j] = p_mtx.matrix[i][j];
}
}
}
-
RID RasterizerCanvasGLES3::light_internal_create() {
- LightInternal * li = memnew( LightInternal );
+ LightInternal *li = memnew(LightInternal);
glGenBuffers(1, &li->ubo);
glBindBuffer(GL_UNIFORM_BUFFER, li->ubo);
@@ -97,60 +95,56 @@ RID RasterizerCanvasGLES3::light_internal_create() {
return light_internal_owner.make_rid(li);
}
-void RasterizerCanvasGLES3::light_internal_update(RID p_rid, Light* p_light) {
+void RasterizerCanvasGLES3::light_internal_update(RID p_rid, Light *p_light) {
- LightInternal * li = light_internal_owner.getornull(p_rid);
+ LightInternal *li = light_internal_owner.getornull(p_rid);
ERR_FAIL_COND(!li);
- store_transform2d(p_light->light_shader_xform,li->ubo_data.light_matrix);
- store_transform2d(p_light->xform_cache.affine_inverse(),li->ubo_data.local_matrix);
- store_camera(p_light->shadow_matrix_cache,li->ubo_data.shadow_matrix);
+ store_transform2d(p_light->light_shader_xform, li->ubo_data.light_matrix);
+ store_transform2d(p_light->xform_cache.affine_inverse(), li->ubo_data.local_matrix);
+ store_camera(p_light->shadow_matrix_cache, li->ubo_data.shadow_matrix);
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
- li->ubo_data.color[i]=p_light->color[i]*p_light->energy;
- li->ubo_data.shadow_color[i]=p_light->shadow_color[i];
+ li->ubo_data.color[i] = p_light->color[i] * p_light->energy;
+ li->ubo_data.shadow_color[i] = p_light->shadow_color[i];
}
- li->ubo_data.light_pos[0]=p_light->light_shader_pos.x;
- li->ubo_data.light_pos[1]=p_light->light_shader_pos.y;
- li->ubo_data.shadowpixel_size=1.0/p_light->shadow_buffer_size;
- li->ubo_data.light_outside_alpha=p_light->mode==VS::CANVAS_LIGHT_MODE_MASK?1.0:0.0;
- li->ubo_data.light_height=p_light->height;
- if (p_light->radius_cache==0)
- li->ubo_data.shadow_gradient=0;
+ li->ubo_data.light_pos[0] = p_light->light_shader_pos.x;
+ li->ubo_data.light_pos[1] = p_light->light_shader_pos.y;
+ li->ubo_data.shadowpixel_size = 1.0 / p_light->shadow_buffer_size;
+ li->ubo_data.light_outside_alpha = p_light->mode == VS::CANVAS_LIGHT_MODE_MASK ? 1.0 : 0.0;
+ li->ubo_data.light_height = p_light->height;
+ if (p_light->radius_cache == 0)
+ li->ubo_data.shadow_gradient = 0;
else
- li->ubo_data.shadow_gradient=p_light->shadow_gradient_length/(p_light->radius_cache*1.1);
-
- li->ubo_data.shadow_distance_mult=(p_light->radius_cache*1.1);
+ li->ubo_data.shadow_gradient = p_light->shadow_gradient_length / (p_light->radius_cache * 1.1);
+ li->ubo_data.shadow_distance_mult = (p_light->radius_cache * 1.1);
glBindBuffer(GL_UNIFORM_BUFFER, li->ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(LightInternal::UBOData), &li->ubo_data);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(LightInternal::UBOData), &li->ubo_data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
}
void RasterizerCanvasGLES3::light_internal_free(RID p_rid) {
- LightInternal * li = light_internal_owner.getornull(p_rid);
+ LightInternal *li = light_internal_owner.getornull(p_rid);
ERR_FAIL_COND(!li);
- glDeleteBuffers(1,&li->ubo);
+ glDeleteBuffers(1, &li->ubo);
light_internal_owner.free(p_rid);
memdelete(li);
-
}
-void RasterizerCanvasGLES3::canvas_begin(){
+void RasterizerCanvasGLES3::canvas_begin() {
if (storage->frame.current_rt && storage->frame.clear_request) {
// a clear request may be pending, so do it
- 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 );
+ 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;
-
+ storage->frame.clear_request = false;
}
/*canvas_shader.unbind();
@@ -162,138 +156,118 @@ void RasterizerCanvasGLES3::canvas_begin(){
reset_canvas();
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT,true);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,false);
-
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT, true);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD, false);
state.canvas_shader.set_custom_shader(0);
state.canvas_shader.bind();
- state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,Color(1,1,1,1));
- state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Transform2D());
- state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform2D());
-
-
-
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE, Color(1, 1, 1, 1));
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX, Transform2D());
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX, Transform2D());
//state.canvas_shader.set_uniform(CanvasShaderGLES3::PROJECTION_MATRIX,state.vp);
//state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Transform());
//state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform());
- glBindBufferBase(GL_UNIFORM_BUFFER,0,state.canvas_item_ubo);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 0, state.canvas_item_ubo);
glBindVertexArray(data.canvas_quad_array);
- state.using_texture_rect=true;
-
-
+ state.using_texture_rect = true;
}
-
-void RasterizerCanvasGLES3::canvas_end(){
-
+void RasterizerCanvasGLES3::canvas_end() {
glBindVertexArray(0);
- glBindBufferBase(GL_UNIFORM_BUFFER,0,0);
-
- state.using_texture_rect=false;
+ glBindBufferBase(GL_UNIFORM_BUFFER, 0, 0);
+ state.using_texture_rect = false;
}
+RasterizerStorageGLES3::Texture *RasterizerCanvasGLES3::_bind_canvas_texture(const RID &p_texture) {
-
-RasterizerStorageGLES3::Texture* RasterizerCanvasGLES3::_bind_canvas_texture(const RID& p_texture) {
-
- if (p_texture==state.current_tex) {
+ if (p_texture == state.current_tex) {
return state.current_tex_ptr;
}
if (p_texture.is_valid()) {
-
- RasterizerStorageGLES3::Texture*texture=storage->texture_owner.getornull(p_texture);
+ RasterizerStorageGLES3::Texture *texture = storage->texture_owner.getornull(p_texture);
if (!texture) {
- state.current_tex=RID();
- state.current_tex_ptr=NULL;
- glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+ state.current_tex = RID();
+ state.current_tex_ptr = NULL;
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
return NULL;
}
if (texture->render_target)
- texture->render_target->used_in_frame=true;
+ texture->render_target->used_in_frame = true;
- glBindTexture(GL_TEXTURE_2D,texture->tex_id);
- state.current_tex=p_texture;
- state.current_tex_ptr=texture;
+ glBindTexture(GL_TEXTURE_2D, texture->tex_id);
+ state.current_tex = p_texture;
+ state.current_tex_ptr = texture;
return texture;
-
} else {
-
- glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
- state.current_tex=RID();
- state.current_tex_ptr=NULL;
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
+ state.current_tex = RID();
+ state.current_tex_ptr = NULL;
}
-
return NULL;
}
void RasterizerCanvasGLES3::_set_texture_rect_mode(bool p_enable) {
- if (state.using_texture_rect==p_enable)
+ if (state.using_texture_rect == p_enable)
return;
if (p_enable) {
glBindVertexArray(data.canvas_quad_array);
-
} else {
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
-
-
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT,p_enable);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_TEXTURE_RECT, p_enable);
state.canvas_shader.bind();
- state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
-
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE, state.canvas_item_modulate);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX, state.final_transform);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX, state.extra_matrix);
- state.using_texture_rect=p_enable;
+ state.using_texture_rect = p_enable;
}
+void RasterizerCanvasGLES3::_draw_polygon(int p_vertex_count, const int *p_indices, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, const RID &p_texture, bool p_singlecolor) {
-void RasterizerCanvasGLES3::_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor) {
-
- bool do_colors=false;
+ bool do_colors = false;
Color m;
if (p_singlecolor) {
m = *p_colors;
- glVertexAttrib4f(VS::ARRAY_COLOR,m.r,m.g,m.b,m.a);
+ glVertexAttrib4f(VS::ARRAY_COLOR, m.r, m.g, m.b, m.a);
} else if (!p_colors) {
- glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+ glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
} else
- do_colors=true;
+ do_colors = true;
RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(p_texture);
#ifndef GLES_NO_CLIENT_ARRAYS
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
- glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, sizeof(Vector2), p_vertices );
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, false, sizeof(Vector2), p_vertices);
if (do_colors) {
glEnableVertexAttribArray(VS::ARRAY_COLOR);
- glVertexAttribPointer( VS::ARRAY_COLOR, 4 ,GL_FLOAT, false, sizeof(Color), p_colors );
+ glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, false, sizeof(Color), p_colors);
} else {
glDisableVertexAttribArray(VS::ARRAY_COLOR);
}
@@ -301,71 +275,69 @@ void RasterizerCanvasGLES3::_draw_polygon(int p_vertex_count, const int* p_indic
if (texture && p_uvs) {
glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
- glVertexAttribPointer( VS::ARRAY_TEX_UV, 2 ,GL_FLOAT, false, sizeof(Vector2), p_uvs );
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, false, sizeof(Vector2), p_uvs);
} else {
glDisableVertexAttribArray(VS::ARRAY_TEX_UV);
}
if (p_indices) {
- glDrawElements(GL_TRIANGLES, p_vertex_count, GL_UNSIGNED_INT, p_indices );
+ glDrawElements(GL_TRIANGLES, p_vertex_count, GL_UNSIGNED_INT, p_indices);
} else {
- glDrawArrays(GL_TRIANGLES,0,p_vertex_count);
+ glDrawArrays(GL_TRIANGLES, 0, p_vertex_count);
}
-
#else //WebGL specific impl.
glBindBuffer(GL_ARRAY_BUFFER, gui_quad_buffer);
float *b = GlobalVertexBuffer;
int ofs = 0;
- if(p_vertex_count > MAX_POLYGON_VERTICES){
+ if (p_vertex_count > MAX_POLYGON_VERTICES) {
print_line("Too many vertices to render");
return;
}
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
- glVertexAttribPointer( VS::ARRAY_VERTEX, 2 ,GL_FLOAT, false, sizeof(float)*2, ((float*)0)+ofs );
- for(int i=0;i<p_vertex_count;i++) {
- b[ofs++]=p_vertices[i].x;
- b[ofs++]=p_vertices[i].y;
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, false, sizeof(float) * 2, ((float *)0) + ofs);
+ for (int i = 0; i < p_vertex_count; i++) {
+ b[ofs++] = p_vertices[i].x;
+ b[ofs++] = p_vertices[i].y;
}
if (p_colors && do_colors) {
glEnableVertexAttribArray(VS::ARRAY_COLOR);
- glVertexAttribPointer( VS::ARRAY_COLOR, 4 ,GL_FLOAT, false, sizeof(float)*4, ((float*)0)+ofs );
- for(int i=0;i<p_vertex_count;i++) {
- b[ofs++]=p_colors[i].r;
- b[ofs++]=p_colors[i].g;
- b[ofs++]=p_colors[i].b;
- b[ofs++]=p_colors[i].a;
+ glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, false, sizeof(float) * 4, ((float *)0) + ofs);
+ for (int i = 0; i < p_vertex_count; i++) {
+ b[ofs++] = p_colors[i].r;
+ b[ofs++] = p_colors[i].g;
+ b[ofs++] = p_colors[i].b;
+ b[ofs++] = p_colors[i].a;
}
} else {
glDisableVertexAttribArray(VS::ARRAY_COLOR);
}
-
if (p_uvs) {
glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
- glVertexAttribPointer( VS::ARRAY_TEX_UV, 2 ,GL_FLOAT, false, sizeof(float)*2, ((float*)0)+ofs );
- for(int i=0;i<p_vertex_count;i++) {
- b[ofs++]=p_uvs[i].x;
- b[ofs++]=p_uvs[i].y;
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, false, sizeof(float) * 2, ((float *)0) + ofs);
+ for (int i = 0; i < p_vertex_count; i++) {
+ b[ofs++] = p_uvs[i].x;
+ b[ofs++] = p_uvs[i].y;
}
} else {
glDisableVertexAttribArray(VS::ARRAY_TEX_UV);
}
- glBufferSubData(GL_ARRAY_BUFFER,0,ofs*4,&b[0]);
+ glBufferSubData(GL_ARRAY_BUFFER, 0, ofs * 4, &b[0]);
//bind the indices buffer.
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer);
- static const int _max_draw_poly_indices = 16*1024; // change this size if needed!!!
+ static const int _max_draw_poly_indices = 16 * 1024; // change this size if needed!!!
ERR_FAIL_COND(p_vertex_count > _max_draw_poly_indices);
static uint16_t _draw_poly_indices[_max_draw_poly_indices];
- for (int i=0; i<p_vertex_count; i++) {
+ for (int i = 0; i < p_vertex_count; i++) {
_draw_poly_indices[i] = p_indices[i];
//OS::get_singleton()->print("ind: %d ", p_indices[i]);
};
@@ -381,99 +353,88 @@ void RasterizerCanvasGLES3::_draw_polygon(int p_vertex_count, const int* p_indic
#endif
storage->frame.canvas_draw_commands++;
-
}
-void RasterizerCanvasGLES3::_draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color* p_colors, const Vector2 *p_uvs) {
-
-
-
- static const GLenum prim[5]={GL_POINTS,GL_POINTS,GL_LINES,GL_TRIANGLES,GL_TRIANGLE_FAN};
+void RasterizerCanvasGLES3::_draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color *p_colors, const Vector2 *p_uvs) {
+ static const GLenum prim[5] = { GL_POINTS, GL_POINTS, GL_LINES, GL_TRIANGLES, GL_TRIANGLE_FAN };
//#define GLES_USE_PRIMITIVE_BUFFER
- int version=0;
- int color_ofs=0;
- int uv_ofs=0;
- int stride=2;
+ int version = 0;
+ int color_ofs = 0;
+ int uv_ofs = 0;
+ int stride = 2;
if (p_colors) { //color
- version|=1;
- color_ofs=stride;
- stride+=4;
+ version |= 1;
+ color_ofs = stride;
+ stride += 4;
}
if (p_uvs) { //uv
- version|=2;
- uv_ofs=stride;
- stride+=2;
+ version |= 2;
+ uv_ofs = stride;
+ stride += 2;
}
+ float b[(2 + 2 + 4) * 4];
- float b[(2+2+4)*4];
-
-
- for(int i=0;i<p_points;i++) {
- b[stride*i+0]=p_vertices[i].x;
- b[stride*i+1]=p_vertices[i].y;
+ for (int i = 0; i < p_points; i++) {
+ b[stride * i + 0] = p_vertices[i].x;
+ b[stride * i + 1] = p_vertices[i].y;
}
if (p_colors) {
- for(int i=0;i<p_points;i++) {
- b[stride*i+color_ofs+0]=p_colors[i].r;
- b[stride*i+color_ofs+1]=p_colors[i].g;
- b[stride*i+color_ofs+2]=p_colors[i].b;
- b[stride*i+color_ofs+3]=p_colors[i].a;
+ for (int i = 0; i < p_points; i++) {
+ b[stride * i + color_ofs + 0] = p_colors[i].r;
+ b[stride * i + color_ofs + 1] = p_colors[i].g;
+ b[stride * i + color_ofs + 2] = p_colors[i].b;
+ b[stride * i + color_ofs + 3] = p_colors[i].a;
}
-
}
if (p_uvs) {
- for(int i=0;i<p_points;i++) {
- b[stride*i+uv_ofs+0]=p_uvs[i].x;
- b[stride*i+uv_ofs+1]=p_uvs[i].y;
+ for (int i = 0; i < p_points; i++) {
+ b[stride * i + uv_ofs + 0] = p_uvs[i].x;
+ b[stride * i + uv_ofs + 1] = p_uvs[i].y;
}
-
}
- glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
- glBufferSubData(GL_ARRAY_BUFFER,0,p_points*stride*4,&b[0]);
+ glBindBuffer(GL_ARRAY_BUFFER, data.primitive_quad_buffer);
+ glBufferSubData(GL_ARRAY_BUFFER, 0, p_points * stride * 4, &b[0]);
glBindVertexArray(data.primitive_quad_buffer_arrays[version]);
- glDrawArrays(prim[p_points],0,p_points);
+ glDrawArrays(prim[p_points], 0, p_points);
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
storage->frame.canvas_draw_commands++;
}
-void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *current_clip,bool &reclip) {
+void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *current_clip, bool &reclip) {
- int cc=p_item->commands.size();
+ int cc = p_item->commands.size();
Item::Command **commands = p_item->commands.ptr();
+ for (int i = 0; i < cc; i++) {
- for(int i=0;i<cc;i++) {
+ Item::Command *c = commands[i];
- Item::Command *c=commands[i];
-
- switch(c->type) {
+ switch (c->type) {
case Item::Command::TYPE_LINE: {
-
- Item::CommandLine* line = static_cast<Item::CommandLine*>(c);
+ Item::CommandLine *line = static_cast<Item::CommandLine *>(c);
_set_texture_rect_mode(false);
-
_bind_canvas_texture(RID());
- glVertexAttrib4f(VS::ARRAY_COLOR,line->color.r,line->color.g,line->color.b,line->color.a);
+ glVertexAttrib4f(VS::ARRAY_COLOR, line->color.r, line->color.g, line->color.b, line->color.a);
- Vector2 verts[2]={
- Vector2(line->from.x,line->from.y),
- Vector2(line->to.x,line->to.y)
+ Vector2 verts[2] = {
+ Vector2(line->from.x, line->from.y),
+ Vector2(line->to.x, line->to.y)
};
#ifdef GLES_OVER_GL
@@ -481,72 +442,66 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
glEnable(GL_LINE_SMOOTH);
#endif
//glLineWidth(line->width);
- _draw_gui_primitive(2,verts,NULL,NULL);
+ _draw_gui_primitive(2, verts, NULL, NULL);
#ifdef GLES_OVER_GL
if (line->antialiased)
glDisable(GL_LINE_SMOOTH);
#endif
-
} break;
case Item::Command::TYPE_RECT: {
- Item::CommandRect* rect = static_cast<Item::CommandRect*>(c);
+ Item::CommandRect *rect = static_cast<Item::CommandRect *>(c);
_set_texture_rect_mode(true);
//set color
- glVertexAttrib4f(VS::ARRAY_COLOR,rect->modulate.r,rect->modulate.g,rect->modulate.b,rect->modulate.a);
+ glVertexAttrib4f(VS::ARRAY_COLOR, rect->modulate.r, rect->modulate.g, rect->modulate.b, rect->modulate.a);
- RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(rect->texture);
+ RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(rect->texture);
- if ( texture ) {
+ if (texture) {
- bool untile=false;
+ bool untile = false;
- if (rect->flags&CANVAS_RECT_TILE && !(texture->flags&VS::TEXTURE_FLAG_REPEAT)) {
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
- untile=true;
+ if (rect->flags & CANVAS_RECT_TILE && !(texture->flags & VS::TEXTURE_FLAG_REPEAT)) {
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ untile = true;
}
- Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
- Rect2 src_rect = (rect->flags&CANVAS_RECT_REGION) ? Rect2( rect->source.pos * texpixel_size, rect->source.size * texpixel_size ) : Rect2(0,0,1,1);
+ Size2 texpixel_size(1.0 / texture->width, 1.0 / texture->height);
+ Rect2 src_rect = (rect->flags & CANVAS_RECT_REGION) ? Rect2(rect->source.pos * texpixel_size, rect->source.size * texpixel_size) : Rect2(0, 0, 1, 1);
- if (rect->flags&CANVAS_RECT_FLIP_H) {
- src_rect.size.x*=-1;
+ if (rect->flags & CANVAS_RECT_FLIP_H) {
+ src_rect.size.x *= -1;
}
- if (rect->flags&CANVAS_RECT_FLIP_V) {
- src_rect.size.y*=-1;
+ if (rect->flags & CANVAS_RECT_FLIP_V) {
+ src_rect.size.y *= -1;
}
- if (rect->flags&CANVAS_RECT_TRANSPOSE) {
+ if (rect->flags & CANVAS_RECT_TRANSPOSE) {
//err..
}
- state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
-
-
- glVertexAttrib4f(1,rect->rect.pos.x,rect->rect.pos.y,rect->rect.size.x,rect->rect.size.y);
- glVertexAttrib4f(2,src_rect.pos.x,src_rect.pos.y,src_rect.size.x,src_rect.size.y);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE, texpixel_size);
+ glVertexAttrib4f(1, rect->rect.pos.x, rect->rect.pos.y, rect->rect.size.x, rect->rect.size.y);
+ glVertexAttrib4f(2, src_rect.pos.x, src_rect.pos.y, src_rect.size.x, src_rect.size.y);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
if (untile) {
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
} else {
-
- glVertexAttrib4f(1,rect->rect.pos.x,rect->rect.pos.y,rect->rect.size.x,rect->rect.size.y);
- glVertexAttrib4f(2,0,0,1,1);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
-
-
+ glVertexAttrib4f(1, rect->rect.pos.x, rect->rect.pos.y, rect->rect.size.x, rect->rect.size.y);
+ glVertexAttrib4f(2, 0, 0, 1, 1);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
storage->frame.canvas_draw_commands++;
@@ -555,80 +510,75 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
case Item::Command::TYPE_NINEPATCH: {
- Item::CommandNinePatch* np = static_cast<Item::CommandNinePatch*>(c);
+ Item::CommandNinePatch *np = static_cast<Item::CommandNinePatch *>(c);
_set_texture_rect_mode(true);
- glVertexAttrib4f(VS::ARRAY_COLOR,np->color.r,np->color.g,np->color.b,np->color.a);
-
+ glVertexAttrib4f(VS::ARRAY_COLOR, np->color.r, np->color.g, np->color.b, np->color.a);
- RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(np->texture);
+ RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(np->texture);
- if ( !texture ) {
+ if (!texture) {
- glVertexAttrib4f(1,np->rect.pos.x,np->rect.pos.y,np->rect.size.x,np->rect.size.y);
- glVertexAttrib4f(2,0,0,1,1);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glVertexAttrib4f(1, np->rect.pos.x, np->rect.pos.y, np->rect.size.x, np->rect.size.y);
+ glVertexAttrib4f(2, 0, 0, 1, 1);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
continue;
}
+ Size2 texpixel_size(1.0 / texture->width, 1.0 / texture->height);
- Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE, texpixel_size);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
-
-#define DSTRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(1,m_x,m_y,m_w,m_h)
-#define SRCRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(2,(m_x)*texpixel_size.x,(m_y)*texpixel_size.y,(m_w)*texpixel_size.x,(m_h)*texpixel_size.y)
+#define DSTRECT(m_x, m_y, m_w, m_h) glVertexAttrib4f(1, m_x, m_y, m_w, m_h)
+#define SRCRECT(m_x, m_y, m_w, m_h) glVertexAttrib4f(2, (m_x)*texpixel_size.x, (m_y)*texpixel_size.y, (m_w)*texpixel_size.x, (m_h)*texpixel_size.y)
//top left
- DSTRECT(np->rect.pos.x,np->rect.pos.y,np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
- SRCRECT(0,0,np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x, np->rect.pos.y, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+ SRCRECT(0, 0, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//top right
- DSTRECT(np->rect.pos.x+np->rect.size.x-np->margin[MARGIN_RIGHT],np->rect.pos.y,np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
- SRCRECT(texture->width-np->margin[MARGIN_RIGHT],0,np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x + np->rect.size.x - np->margin[MARGIN_RIGHT], np->rect.pos.y, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+ SRCRECT(texture->width - np->margin[MARGIN_RIGHT], 0, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//bottom right
- DSTRECT(np->rect.pos.x+np->rect.size.x-np->margin[MARGIN_RIGHT],np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_RIGHT],np->margin[MARGIN_BOTTOM]);
- SRCRECT(texture->width-np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_RIGHT],np->margin[MARGIN_BOTTOM]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x + np->rect.size.x - np->margin[MARGIN_RIGHT], np->rect.pos.y + np->rect.size.y - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
+ SRCRECT(texture->width - np->margin[MARGIN_RIGHT], texture->height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//bottom left
- DSTRECT(np->rect.pos.x,np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_LEFT],np->margin[MARGIN_BOTTOM]);
- SRCRECT(0,texture->height-np->margin[MARGIN_BOTTOM],np->margin[MARGIN_LEFT],np->margin[MARGIN_BOTTOM]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
-
+ DSTRECT(np->rect.pos.x, np->rect.pos.y + np->rect.size.y - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
+ SRCRECT(0, texture->height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//top
- DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y,np->rect.size.width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
- SRCRECT(np->margin[MARGIN_LEFT],0,texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y, np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+ SRCRECT(np->margin[MARGIN_LEFT], 0, texture->width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//bottom
- DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y+np->rect.size.y-np->margin[MARGIN_BOTTOM],np->rect.size.width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP]);
- SRCRECT(np->margin[MARGIN_LEFT],texture->height-np->margin[MARGIN_BOTTOM],texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
-
+ DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y + np->rect.size.y - np->margin[MARGIN_BOTTOM], np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+ SRCRECT(np->margin[MARGIN_LEFT], texture->height - np->margin[MARGIN_BOTTOM], texture->width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//left
- DSTRECT(np->rect.pos.x,np->rect.pos.y+np->margin[MARGIN_TOP],np->margin[MARGIN_LEFT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- SRCRECT(0,np->margin[MARGIN_TOP],np->margin[MARGIN_LEFT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x, np->rect.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ SRCRECT(0, np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], texture->height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//right
- DSTRECT(np->rect.pos.x+np->rect.size.width-np->margin[MARGIN_RIGHT],np->rect.pos.y+np->margin[MARGIN_TOP],np->margin[MARGIN_RIGHT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- SRCRECT(texture->width-np->margin[MARGIN_RIGHT],np->margin[MARGIN_TOP],np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ DSTRECT(np->rect.pos.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ SRCRECT(texture->width - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], texture->height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
if (np->draw_center) {
//center
- DSTRECT(np->rect.pos.x+np->margin[MARGIN_LEFT],np->rect.pos.y+np->margin[MARGIN_TOP],np->rect.size.x-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],np->rect.size.height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- SRCRECT(np->margin[MARGIN_LEFT],np->margin[MARGIN_TOP],texture->width-np->margin[MARGIN_LEFT]-np->margin[MARGIN_RIGHT],texture->height-np->margin[MARGIN_TOP]-np->margin[MARGIN_BOTTOM]);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
-
+ DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y + np->margin[MARGIN_TOP], np->rect.size.x - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ SRCRECT(np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP], texture->width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], texture->height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
#undef SRCRECT
@@ -639,41 +589,39 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
case Item::Command::TYPE_PRIMITIVE: {
- Item::CommandPrimitive* primitive = static_cast<Item::CommandPrimitive*>(c);
+ Item::CommandPrimitive *primitive = static_cast<Item::CommandPrimitive *>(c);
_set_texture_rect_mode(false);
- ERR_CONTINUE( primitive->points.size()<1);
+ ERR_CONTINUE(primitive->points.size() < 1);
- RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(primitive->texture);
-
- if (texture ) {
- Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
- state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+ RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(primitive->texture);
+ if (texture) {
+ Size2 texpixel_size(1.0 / texture->width, 1.0 / texture->height);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE, texpixel_size);
}
- if (primitive->colors.size()==1 && primitive->points.size()>1) {
+ if (primitive->colors.size() == 1 && primitive->points.size() > 1) {
Color c = primitive->colors[0];
- glVertexAttrib4f(VS::ARRAY_COLOR,c.r,c.g,c.b,c.a);
+ glVertexAttrib4f(VS::ARRAY_COLOR, c.r, c.g, c.b, c.a);
} else if (primitive->colors.empty()) {
- glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+ glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
}
- _draw_gui_primitive(primitive->points.size(),primitive->points.ptr(),primitive->colors.ptr(),primitive->uvs.ptr());
+ _draw_gui_primitive(primitive->points.size(), primitive->points.ptr(), primitive->colors.ptr(), primitive->uvs.ptr());
} break;
case Item::Command::TYPE_POLYGON: {
- Item::CommandPolygon* polygon = static_cast<Item::CommandPolygon*>(c);
+ Item::CommandPolygon *polygon = static_cast<Item::CommandPolygon *>(c);
_set_texture_rect_mode(false);
- RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(polygon->texture);
-
- if (texture ) {
- Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
- state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
+ RasterizerStorageGLES3::Texture *texture = _bind_canvas_texture(polygon->texture);
+ if (texture) {
+ Size2 texpixel_size(1.0 / texture->width, 1.0 / texture->height);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE, texpixel_size);
}
//_draw_polygon(polygon->count,polygon->indices.ptr(),polygon->points.ptr(),polygon->uvs.ptr(),polygon->colors.ptr(),polygon->texture,polygon->colors.size()==1);
@@ -682,59 +630,57 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
_set_texture_rect_mode(false);
- Item::CommandCircle* circle = static_cast<Item::CommandCircle*>(c);
- static const int numpoints=32;
- Vector2 points[numpoints+1];
- points[numpoints]=circle->pos;
- int indices[numpoints*3];
+ Item::CommandCircle *circle = static_cast<Item::CommandCircle *>(c);
+ static const int numpoints = 32;
+ Vector2 points[numpoints + 1];
+ points[numpoints] = circle->pos;
+ int indices[numpoints * 3];
- for(int i=0;i<numpoints;i++) {
+ for (int i = 0; i < numpoints; i++) {
- points[i]=circle->pos+Vector2( Math::sin(i*Math_PI*2.0/numpoints),Math::cos(i*Math_PI*2.0/numpoints) )*circle->radius;
- indices[i*3+0]=i;
- indices[i*3+1]=(i+1)%numpoints;
- indices[i*3+2]=numpoints;
+ points[i] = circle->pos + Vector2(Math::sin(i * Math_PI * 2.0 / numpoints), Math::cos(i * Math_PI * 2.0 / numpoints)) * circle->radius;
+ indices[i * 3 + 0] = i;
+ indices[i * 3 + 1] = (i + 1) % numpoints;
+ indices[i * 3 + 2] = numpoints;
}
//_draw_polygon(numpoints*3,indices,points,NULL,&circle->color,RID(),true);
//canvas_draw_circle(circle->indices.size(),circle->indices.ptr(),circle->points.ptr(),circle->uvs.ptr(),circle->colors.ptr(),circle->texture,circle->colors.size()==1);
} break;
case Item::Command::TYPE_TRANSFORM: {
- Item::CommandTransform* transform = static_cast<Item::CommandTransform*>(c);
- state.extra_matrix=transform->xform;
- state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
+ Item::CommandTransform *transform = static_cast<Item::CommandTransform *>(c);
+ state.extra_matrix = transform->xform;
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX, state.extra_matrix);
} break;
case Item::Command::TYPE_CLIP_IGNORE: {
- Item::CommandClipIgnore* ci = static_cast<Item::CommandClipIgnore*>(c);
+ Item::CommandClipIgnore *ci = static_cast<Item::CommandClipIgnore *>(c);
if (current_clip) {
- if (ci->ignore!=reclip) {
+ if (ci->ignore != reclip) {
if (ci->ignore) {
glDisable(GL_SCISSOR_TEST);
- reclip=true;
- } else {
+ reclip = true;
+ } else {
glEnable(GL_SCISSOR_TEST);
//glScissor(viewport.x+current_clip->final_clip_rect.pos.x,viewport.y+ (viewport.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),
//current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
int x = current_clip->final_clip_rect.pos.x;
- int y = storage->frame.current_rt->height - ( current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.y );
+ int y = storage->frame.current_rt->height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.y);
int w = current_clip->final_clip_rect.size.x;
int h = current_clip->final_clip_rect.size.y;
- glScissor(x,y,w,h);
+ glScissor(x, y, w, h);
- reclip=false;
+ reclip = false;
}
}
}
-
-
} break;
}
}
@@ -795,60 +741,52 @@ void RasterizerGLES2::_canvas_item_setup_shader_params(CanvasItemMaterial *mater
#endif
-void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const Color& p_modulate,Light *p_light) {
-
-
+void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list, int p_z, const Color &p_modulate, Light *p_light) {
+ Item *current_clip = NULL;
+ RasterizerStorageGLES3::Shader *shader_cache = NULL;
- Item *current_clip=NULL;
- RasterizerStorageGLES3::Shader *shader_cache=NULL;
+ bool rebind_shader = true;
- bool rebind_shader=true;
+ Size2 rt_size = Size2(storage->frame.current_rt->width, storage->frame.current_rt->height);
- Size2 rt_size = Size2(storage->frame.current_rt->width,storage->frame.current_rt->height);
-
-
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD, false);
glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
glBufferData(GL_UNIFORM_BUFFER, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
- state.current_tex=RID();
- state.current_tex_ptr=NULL;
+ state.current_tex = RID();
+ state.current_tex_ptr = NULL;
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
-
- int last_blend_mode=-1;
+ int last_blend_mode = -1;
RID canvas_last_material;
- bool prev_distance_field=false;
-
- while(p_item_list) {
+ bool prev_distance_field = false;
- Item *ci=p_item_list;
+ while (p_item_list) {
+ Item *ci = p_item_list;
- if (prev_distance_field!=ci->distance_field) {
+ if (prev_distance_field != ci->distance_field) {
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,ci->distance_field);
- prev_distance_field=ci->distance_field;
- rebind_shader=true;
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD, ci->distance_field);
+ prev_distance_field = ci->distance_field;
+ rebind_shader = true;
}
+ if (current_clip != ci->final_clip_owner) {
- if (current_clip!=ci->final_clip_owner) {
-
- current_clip=ci->final_clip_owner;
+ current_clip = ci->final_clip_owner;
//setup clip
if (current_clip) {
glEnable(GL_SCISSOR_TEST);
- glScissor(current_clip->final_clip_rect.pos.x,(rt_size.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
-
+ glScissor(current_clip->final_clip_rect.pos.x, (rt_size.height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
} else {
@@ -893,13 +831,12 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
#endif
-
//begin rect
- Item *material_owner = ci->material_owner?ci->material_owner:ci;
+ Item *material_owner = ci->material_owner ? ci->material_owner : ci;
RID material = material_owner->material;
- if (material!=canvas_last_material || rebind_shader) {
+ if (material != canvas_last_material || rebind_shader) {
RasterizerStorageGLES3::Material *material_ptr = storage->material_owner.getornull(material);
RasterizerStorageGLES3::Shader *shader_ptr = NULL;
@@ -908,46 +845,44 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
shader_ptr = material_ptr->shader;
- if (shader_ptr && shader_ptr->mode!=VS::SHADER_CANVAS_ITEM) {
- shader_ptr=NULL; //do not use non canvasitem shader
+ if (shader_ptr && shader_ptr->mode != VS::SHADER_CANVAS_ITEM) {
+ shader_ptr = NULL; //do not use non canvasitem shader
}
}
-
-
- if (shader_ptr && shader_ptr!=shader_cache) {
+ if (shader_ptr && shader_ptr != shader_cache) {
state.canvas_shader.set_custom_shader(shader_ptr->custom_code_id);
state.canvas_shader.bind();
if (material_ptr->ubo_id) {
- glBindBufferBase(GL_UNIFORM_BUFFER,2,material_ptr->ubo_id);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 2, material_ptr->ubo_id);
}
int tc = material_ptr->textures.size();
- RID* textures = material_ptr->textures.ptr();
- ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = shader_ptr->texture_hints.ptr();
+ RID *textures = material_ptr->textures.ptr();
+ ShaderLanguage::ShaderNode::Uniform::Hint *texture_hints = shader_ptr->texture_hints.ptr();
- for(int i=0;i<tc;i++) {
+ for (int i = 0; i < tc; i++) {
- glActiveTexture(GL_TEXTURE1+i);
+ glActiveTexture(GL_TEXTURE1 + i);
- RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
+ RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull(textures[i]);
if (!t) {
- switch(texture_hints[i]) {
+ switch (texture_hints[i]) {
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
- glBindTexture(GL_TEXTURE_2D,storage->resources.black_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.black_tex);
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
- glBindTexture(GL_TEXTURE_2D,storage->resources.aniso_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.aniso_tex);
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
- glBindTexture(GL_TEXTURE_2D,storage->resources.normal_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.normal_tex);
} break;
default: {
- glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
} break;
}
@@ -958,116 +893,108 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
if (storage->config.srgb_decode_supported && t->using_srgb) {
//no srgb in 2D
- glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
- t->using_srgb=false;
+ glTexParameteri(t->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT);
+ t->using_srgb = false;
}
- glBindTexture(t->target,t->tex_id);
+ glBindTexture(t->target, t->tex_id);
}
-
} else if (!shader_ptr) {
state.canvas_shader.set_custom_shader(0);
state.canvas_shader.bind();
-
}
- shader_cache=shader_ptr;
-
- canvas_last_material=material;
- rebind_shader=false;
+ shader_cache = shader_ptr;
+ canvas_last_material = material;
+ rebind_shader = false;
}
int blend_mode = shader_cache ? shader_cache->canvas_item.blend_mode : RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX;
- bool unshaded = shader_cache && (shader_cache->canvas_item.light_mode==RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_UNSHADED || blend_mode!=RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX);
- bool reclip=false;
+ bool unshaded = shader_cache && (shader_cache->canvas_item.light_mode == RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_UNSHADED || blend_mode != RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX);
+ bool reclip = false;
- if (last_blend_mode!=blend_mode) {
+ if (last_blend_mode != blend_mode) {
- switch(blend_mode) {
+ switch (blend_mode) {
- case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX: {
+ case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX: {
glBlendEquation(GL_FUNC_ADD);
if (storage->frame.current_rt && 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 {
+ } else {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
- } break;
- case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_ADD: {
+ } break;
+ case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_ADD: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
- } break;
- case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_SUB: {
+ } break;
+ case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_SUB: {
glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
- } break;
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+ } break;
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MUL: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_DST_COLOR,GL_ZERO);
+ glBlendFunc(GL_DST_COLOR, GL_ZERO);
} break;
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
+ glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
} break;
-
}
- last_blend_mode=blend_mode;
+ last_blend_mode = blend_mode;
}
state.canvas_item_modulate = unshaded ? ci->final_modulate : Color(
- ci->final_modulate.r * p_modulate.r,
- ci->final_modulate.g * p_modulate.g,
- ci->final_modulate.b * p_modulate.b,
- ci->final_modulate.a * p_modulate.a );
+ ci->final_modulate.r * p_modulate.r,
+ ci->final_modulate.g * p_modulate.g,
+ ci->final_modulate.b * p_modulate.b,
+ ci->final_modulate.a * p_modulate.a);
state.final_transform = ci->final_transform;
- state.extra_matrix=Transform2D();
+ state.extra_matrix = Transform2D();
- state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE, state.canvas_item_modulate);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX, state.final_transform);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX, state.extra_matrix);
+ if (unshaded || (state.canvas_item_modulate.a > 0.001 && (!shader_cache || shader_cache->canvas_item.light_mode != RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY) && !ci->light_masked))
+ _canvas_item_render_commands(ci, current_clip, reclip);
- if (unshaded || (state.canvas_item_modulate.a>0.001 && (!shader_cache || shader_cache->canvas_item.light_mode!=RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY) && !ci->light_masked ))
- _canvas_item_render_commands(ci,current_clip,reclip);
-
- if ((blend_mode==RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX || blend_mode==RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA) && p_light && !unshaded) {
+ if ((blend_mode == RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX || blend_mode == RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA) && p_light && !unshaded) {
Light *light = p_light;
- bool light_used=false;
- VS::CanvasLightMode mode=VS::CANVAS_LIGHT_MODE_ADD;
- state.canvas_item_modulate=ci->final_modulate; // remove the canvas modulate
-
+ bool light_used = false;
+ VS::CanvasLightMode mode = VS::CANVAS_LIGHT_MODE_ADD;
+ state.canvas_item_modulate = ci->final_modulate; // remove the canvas modulate
- while(light) {
+ while (light) {
-
- if (ci->light_mask&light->item_mask && p_z>=light->z_min && p_z<=light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache,light->rect_cache)) {
+ if (ci->light_mask & light->item_mask && p_z >= light->z_min && p_z <= light->z_max && ci->global_rect_cache.intersects_transformed(light->xform_cache, light->rect_cache)) {
//intersects this light
- if (!light_used || mode!=light->mode) {
+ if (!light_used || mode != light->mode) {
- mode=light->mode;
+ mode = light->mode;
- switch(mode) {
+ switch (mode) {
case VS::CANVAS_LIGHT_MODE_ADD: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
} break;
case VS::CANVAS_LIGHT_MODE_SUB: {
glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
} break;
case VS::CANVAS_LIGHT_MODE_MIX:
case VS::CANVAS_LIGHT_MODE_MASK: {
@@ -1076,90 +1003,80 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
} break;
}
-
}
if (!light_used) {
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,true);
- light_used=true;
-
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING, true);
+ light_used = true;
}
+ bool has_shadow = light->shadow_buffer.is_valid() && ci->light_mask & light->item_shadow_mask;
- bool has_shadow = light->shadow_buffer.is_valid() && ci->light_mask&light->item_shadow_mask;
-
-
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,has_shadow);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS, has_shadow);
if (has_shadow) {
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_USE_GRADIENT,light->shadow_gradient_length>0);
- switch(light->shadow_filter) {
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_USE_GRADIENT, light->shadow_gradient_length > 0);
+ switch (light->shadow_filter) {
- case VS::CANVAS_LIGHT_FILTER_NONE: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,true); break;
- case VS::CANVAS_LIGHT_FILTER_PCF3: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3,true); break;
- case VS::CANVAS_LIGHT_FILTER_PCF5: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,true); break;
- case VS::CANVAS_LIGHT_FILTER_PCF9: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9,true); break;
- case VS::CANVAS_LIGHT_FILTER_PCF13: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,true); break;
+ case VS::CANVAS_LIGHT_FILTER_NONE: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST, true); break;
+ case VS::CANVAS_LIGHT_FILTER_PCF3: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3, true); break;
+ case VS::CANVAS_LIGHT_FILTER_PCF5: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5, true); break;
+ case VS::CANVAS_LIGHT_FILTER_PCF9: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9, true); break;
+ case VS::CANVAS_LIGHT_FILTER_PCF13: state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13, true); break;
}
-
-
}
bool light_rebind = state.canvas_shader.bind();
if (light_rebind) {
- state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
- state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Transform2D());
-
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE, state.canvas_item_modulate);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX, state.final_transform);
+ state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX, Transform2D());
}
- glBindBufferBase(GL_UNIFORM_BUFFER,1,static_cast<LightInternal*>(light->light_internal.get_data())->ubo);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 1, static_cast<LightInternal *>(light->light_internal.get_data())->ubo);
if (has_shadow) {
RasterizerStorageGLES3::CanvasLightShadow *cls = storage->canvas_light_shadow_owner.get(light->shadow_buffer);
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-2);
- glBindTexture(GL_TEXTURE_2D,cls->distance);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 2);
+ glBindTexture(GL_TEXTURE_2D, cls->distance);
/*canvas_shader.set_uniform(CanvasShaderGLES3::SHADOW_MATRIX,light->shadow_matrix_cache);
canvas_shader.set_uniform(CanvasShaderGLES3::SHADOW_ESM_MULTIPLIER,light->shadow_esm_mult);
canvas_shader.set_uniform(CanvasShaderGLES3::LIGHT_SHADOW_COLOR,light->shadow_color);*/
-
}
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-1);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 1);
RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull(light->texture);
if (!t) {
- glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
} else {
- glBindTexture(t->target,t->tex_id);
+ glBindTexture(t->target, t->tex_id);
}
glActiveTexture(GL_TEXTURE0);
- _canvas_item_render_commands(ci,current_clip,reclip); //redraw using light
-
+ _canvas_item_render_commands(ci, current_clip, reclip); //redraw using light
}
- light=light->next_ptr;
+ light = light->next_ptr;
}
if (light_used) {
-
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9,false);
- state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_LIGHTING, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_SHADOWS, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_NEAREST, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF3, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF5, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9, false);
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13, false);
state.canvas_shader.bind();
- last_blend_mode=-1;
+ last_blend_mode = -1;
/*
//this is set again, so it should not be needed anyway?
@@ -1185,69 +1102,58 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
//@TODO RESET canvas_blend_mode
*/
}
-
-
}
if (reclip) {
glEnable(GL_SCISSOR_TEST);
- glScissor(current_clip->final_clip_rect.pos.x,(rt_size.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
-
-
+ glScissor(current_clip->final_clip_rect.pos.x, (rt_size.height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
}
-
-
- p_item_list=p_item_list->next;
+ p_item_list = p_item_list->next;
}
if (current_clip) {
glDisable(GL_SCISSOR_TEST);
}
-
}
-void RasterizerCanvasGLES3::canvas_debug_viewport_shadows(Light* p_lights_with_shadow){
+void RasterizerCanvasGLES3::canvas_debug_viewport_shadows(Light *p_lights_with_shadow) {
- Light* light=p_lights_with_shadow;
+ Light *light = p_lights_with_shadow;
canvas_begin(); //reset
- glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+ glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
int h = 10;
int w = storage->frame.current_rt->width;
int ofs = h;
glDisable(GL_BLEND);
//print_line(" debug lights ");
- while(light) {
-
+ while (light) {
//print_line("debug light");
if (light->shadow_buffer.is_valid()) {
//print_line("sb is valid");
- RasterizerStorageGLES3::CanvasLightShadow * sb = storage->canvas_light_shadow_owner.get(light->shadow_buffer);
+ RasterizerStorageGLES3::CanvasLightShadow *sb = storage->canvas_light_shadow_owner.get(light->shadow_buffer);
if (sb) {
- glBindTexture(GL_TEXTURE_2D,sb->distance);
+ glBindTexture(GL_TEXTURE_2D, sb->distance);
//glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
- draw_generic_textured_rect(Rect2(h,ofs,w-h*2,h),Rect2(0,0,1,1));
- ofs+=h*2;
-
+ draw_generic_textured_rect(Rect2(h, ofs, w - h * 2, h), Rect2(0, 0, 1, 1));
+ ofs += h * 2;
}
}
- light=light->shadows_next_ptr;
+ light = light->shadows_next_ptr;
}
}
-
-void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
+void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders, CameraMatrix *p_xform_cache) {
RasterizerStorageGLES3::CanvasLightShadow *cls = storage->canvas_light_shadow_owner.get(p_buffer);
ERR_FAIL_COND(!cls);
-
glDisable(GL_BLEND);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_DITHER);
@@ -1261,73 +1167,71 @@ void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, cons
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
state.canvas_shadow_shader.bind();
- glViewport(0, 0, cls->size,cls->height);
+ glViewport(0, 0, cls->size, cls->height);
glClearDepth(1.0f);
- glClearColor(1,1,1,1);
- glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+ glClearColor(1, 1, 1, 1);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- VS::CanvasOccluderPolygonCullMode cull=VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+ VS::CanvasOccluderPolygonCullMode cull = VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
-
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
//make sure it remains orthogonal, makes easy to read angle later
Transform light;
- light.origin[0]=p_light_xform[2][0];
- light.origin[1]=p_light_xform[2][1];
- light.basis[0][0]=p_light_xform[0][0];
- light.basis[0][1]=p_light_xform[1][0];
- light.basis[1][0]=p_light_xform[0][1];
- light.basis[1][1]=p_light_xform[1][1];
+ light.origin[0] = p_light_xform[2][0];
+ light.origin[1] = p_light_xform[2][1];
+ light.basis[0][0] = p_light_xform[0][0];
+ light.basis[0][1] = p_light_xform[1][0];
+ light.basis[1][0] = p_light_xform[0][1];
+ light.basis[1][1] = p_light_xform[1][1];
//light.basis.scale(Vector3(to_light.elements[0].length(),to_light.elements[1].length(),1));
//p_near=1;
CameraMatrix projection;
{
- real_t fov = 90;
+ real_t fov = 90;
real_t nearp = p_near;
real_t farp = p_far;
real_t aspect = 1.0;
- real_t ymax = nearp * Math::tan( Math::deg2rad( fov * 0.5 ) );
- real_t ymin = - ymax;
+ real_t ymax = nearp * Math::tan(Math::deg2rad(fov * 0.5));
+ real_t ymin = -ymax;
real_t xmin = ymin * aspect;
real_t xmax = ymax * aspect;
- projection.set_frustum( xmin, xmax, ymin, ymax, nearp, farp );
+ projection.set_frustum(xmin, xmax, ymin, ymax, nearp, farp);
}
- Vector3 cam_target=Basis(Vector3(0,0,Math_PI*2*(i/4.0))).xform(Vector3(0,1,0));
- projection = projection * CameraMatrix(Transform().looking_at(cam_target,Vector3(0,0,-1)).affine_inverse());
-
- state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::PROJECTION_MATRIX,projection);
- state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::LIGHT_MATRIX,light);
- state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::DISTANCE_NORM,1.0/p_far);
+ Vector3 cam_target = Basis(Vector3(0, 0, Math_PI * 2 * (i / 4.0))).xform(Vector3(0, 1, 0));
+ projection = projection * CameraMatrix(Transform().looking_at(cam_target, Vector3(0, 0, -1)).affine_inverse());
+ state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::PROJECTION_MATRIX, projection);
+ state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::LIGHT_MATRIX, light);
+ state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::DISTANCE_NORM, 1.0 / p_far);
- if (i==0)
- *p_xform_cache=projection;
+ if (i == 0)
+ *p_xform_cache = projection;
- glViewport(0, (cls->height/4)*i, cls->size,cls->height/4);
+ glViewport(0, (cls->height / 4) * i, cls->size, cls->height / 4);
- LightOccluderInstance *instance=p_occluders;
+ LightOccluderInstance *instance = p_occluders;
- while(instance) {
+ while (instance) {
RasterizerStorageGLES3::CanvasOccluder *cc = storage->canvas_occluder_owner.get(instance->polygon_buffer);
- if (!cc || cc->len==0 || !(p_light_mask&instance->light_mask)) {
+ if (!cc || cc->len == 0 || !(p_light_mask & instance->light_mask)) {
- instance=instance->next;
+ instance = instance->next;
continue;
}
- state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::WORLD_MATRIX,instance->xform_cache);
- if (cull!=instance->cull_cache) {
+ state.canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES3::WORLD_MATRIX, instance->xform_cache);
+ if (cull != instance->cull_cache) {
- cull=instance->cull_cache;
- switch(cull) {
+ cull = instance->cull_cache;
+ switch (cull) {
case VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED: {
glDisable(GL_CULL_FACE);
@@ -1346,7 +1250,7 @@ void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, cons
} break;
}
}
-/*
+ /*
if (i==0) {
for(int i=0;i<cc->lines.size();i++) {
Vector2 p = instance->xform_cache.xform(cc->lines.get(i));
@@ -1359,31 +1263,26 @@ void RasterizerCanvasGLES3::canvas_light_shadow_buffer_update(RID p_buffer, cons
}
}
*/
- glBindBuffer(GL_ARRAY_BUFFER,cc->vertex_id);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,cc->index_id);
+ glBindBuffer(GL_ARRAY_BUFFER, cc->vertex_id);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cc->index_id);
glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false, 0, 0);
- glDrawElements(GL_TRIANGLES,cc->len*3,GL_UNSIGNED_SHORT,0);
+ glDrawElements(GL_TRIANGLES, cc->len * 3, GL_UNSIGNED_SHORT, 0);
-
- instance=instance->next;
+ instance = instance->next;
}
-
-
}
glDisableVertexAttribArray(VS::ARRAY_VERTEX);
- glBindBuffer(GL_ARRAY_BUFFER,0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
void RasterizerCanvasGLES3::reset_canvas() {
-
if (storage->frame.current_rt) {
glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
- glColorMask(1,1,1,1); //don't touch alpha
+ glColorMask(1, 1, 1, 1); //don't touch alpha
}
-
glBindVertexArray(0);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
@@ -1392,23 +1291,21 @@ void RasterizerCanvasGLES3::reset_canvas() {
glBlendEquation(GL_FUNC_ADD);
if (storage->frame.current_rt && 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 {
+ } else {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
//glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
//glLineWidth(1.0);
- glBindBuffer(GL_ARRAY_BUFFER,0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
- for(int i=0;i<VS::ARRAY_MAX;i++) {
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ for (int i = 0; i < VS::ARRAY_MAX; i++) {
glDisableVertexAttribArray(i);
}
glActiveTexture(GL_TEXTURE0);
- glBindTexture( GL_TEXTURE_2D, storage->resources.white_tex );
-
+ glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
- glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+ glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
Transform canvas_transform;
@@ -1419,119 +1316,107 @@ void RasterizerCanvasGLES3::reset_canvas() {
csy = -1.0;
}
canvas_transform.translate(-(storage->frame.current_rt->width / 2.0f), -(storage->frame.current_rt->height / 2.0f), 0.0f);
- canvas_transform.scale( Vector3( 2.0f / storage->frame.current_rt->width, csy * -2.0f / storage->frame.current_rt->height, 1.0f ) );
+ canvas_transform.scale(Vector3(2.0f / storage->frame.current_rt->width, csy * -2.0f / storage->frame.current_rt->height, 1.0f));
} else {
Vector2 ssize = OS::get_singleton()->get_window_size();
canvas_transform.translate(-(ssize.width / 2.0f), -(ssize.height / 2.0f), 0.0f);
- canvas_transform.scale( Vector3( 2.0f / ssize.width, -2.0f / ssize.height, 1.0f ) );
-
+ canvas_transform.scale(Vector3(2.0f / ssize.width, -2.0f / ssize.height, 1.0f));
}
- state.vp=canvas_transform;
+ state.vp = canvas_transform;
- store_transform(canvas_transform,state.canvas_item_ubo_data.projection_matrix);
- for(int i=0;i<4;i++) {
- state.canvas_item_ubo_data.time[i]=storage->frame.time[i];
+ store_transform(canvas_transform, state.canvas_item_ubo_data.projection_matrix);
+ for (int i = 0; i < 4; i++) {
+ state.canvas_item_ubo_data.time[i] = storage->frame.time[i];
}
glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
- state.canvas_texscreen_used=false;
-
-
+ state.canvas_texscreen_used = false;
}
+void RasterizerCanvasGLES3::draw_generic_textured_rect(const Rect2 &p_rect, const Rect2 &p_src) {
-void RasterizerCanvasGLES3::draw_generic_textured_rect(const Rect2& p_rect, const Rect2& p_src) {
-
-
- glVertexAttrib4f(1,p_rect.pos.x,p_rect.pos.y,p_rect.size.x,p_rect.size.y);
- glVertexAttrib4f(2,p_src.pos.x,p_src.pos.y,p_src.size.x,p_src.size.y);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glVertexAttrib4f(1, p_rect.pos.x, p_rect.pos.y, p_rect.size.x, p_rect.size.y);
+ glVertexAttrib4f(2, p_src.pos.x, p_src.pos.y, p_src.size.x, p_src.size.y);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
void RasterizerCanvasGLES3::initialize() {
-
{
//quad buffers
- glGenBuffers(1,&data.canvas_quad_vertices);
- glBindBuffer(GL_ARRAY_BUFFER,data.canvas_quad_vertices);
+ glGenBuffers(1, &data.canvas_quad_vertices);
+ glBindBuffer(GL_ARRAY_BUFFER, data.canvas_quad_vertices);
{
- const float qv[8]={
- 0,0,
- 0,1,
- 1,1,
- 1,0
+ const float qv[8] = {
+ 0, 0,
+ 0, 1,
+ 1, 1,
+ 1, 0
};
- glBufferData(GL_ARRAY_BUFFER,sizeof(float)*8,qv,GL_STATIC_DRAW);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 8, qv, GL_STATIC_DRAW);
}
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
-
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
- glGenVertexArrays(1,&data.canvas_quad_array);
+ glGenVertexArrays(1, &data.canvas_quad_array);
glBindVertexArray(data.canvas_quad_array);
- glBindBuffer(GL_ARRAY_BUFFER,data.canvas_quad_vertices);
- glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,sizeof(float)*2,0);
+ glBindBuffer(GL_ARRAY_BUFFER, data.canvas_quad_vertices);
+ glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
}
{
- glGenBuffers(1,&data.primitive_quad_buffer);
- glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
- glBufferData(GL_ARRAY_BUFFER,(2+2+4)*4*sizeof(float),NULL,GL_DYNAMIC_DRAW); //allocate max size
- glBindBuffer(GL_ARRAY_BUFFER,0);
+ glGenBuffers(1, &data.primitive_quad_buffer);
+ glBindBuffer(GL_ARRAY_BUFFER, data.primitive_quad_buffer);
+ glBufferData(GL_ARRAY_BUFFER, (2 + 2 + 4) * 4 * sizeof(float), NULL, GL_DYNAMIC_DRAW); //allocate max size
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
-
- for(int i=0;i<4;i++) {
- glGenVertexArrays(1,&data.primitive_quad_buffer_arrays[i]);
+ for (int i = 0; i < 4; i++) {
+ glGenVertexArrays(1, &data.primitive_quad_buffer_arrays[i]);
glBindVertexArray(data.primitive_quad_buffer_arrays[i]);
- glBindBuffer(GL_ARRAY_BUFFER,data.primitive_quad_buffer);
+ glBindBuffer(GL_ARRAY_BUFFER, data.primitive_quad_buffer);
- int uv_ofs=0;
- int color_ofs=0;
- int stride=2*4;
+ int uv_ofs = 0;
+ int color_ofs = 0;
+ int stride = 2 * 4;
- if (i&1) { //color
- color_ofs=stride;
- stride+=4*4;
+ if (i & 1) { //color
+ color_ofs = stride;
+ stride += 4 * 4;
}
- if (i&2) { //uv
- uv_ofs=stride;
- stride+=2*4;
+ if (i & 2) { //uv
+ uv_ofs = stride;
+ stride += 2 * 4;
}
-
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
- glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+0);
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + 0);
- if (i&1) {
+ if (i & 1) {
glEnableVertexAttribArray(VS::ARRAY_COLOR);
- glVertexAttribPointer(VS::ARRAY_COLOR,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+color_ofs);
+ glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + color_ofs);
}
- if (i&2) {
+ if (i & 2) {
glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
- glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+uv_ofs);
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + uv_ofs);
}
glBindVertexArray(0);
}
}
-
- store_transform(Transform(),state.canvas_item_ubo_data.projection_matrix);
-
+ store_transform(Transform(), state.canvas_item_ubo_data.projection_matrix);
glGenBuffers(1, &state.canvas_item_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
@@ -1542,20 +1427,15 @@ void RasterizerCanvasGLES3::initialize() {
state.canvas_shader.set_base_material_tex_index(1);
state.canvas_shadow_shader.init();
- state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_RGBA_SHADOWS,storage->config.use_rgba_2d_shadows);
- state.canvas_shadow_shader.set_conditional(CanvasShadowShaderGLES3::USE_RGBA_SHADOWS,storage->config.use_rgba_2d_shadows);
-
-
+ state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_RGBA_SHADOWS, storage->config.use_rgba_2d_shadows);
+ state.canvas_shadow_shader.set_conditional(CanvasShadowShaderGLES3::USE_RGBA_SHADOWS, storage->config.use_rgba_2d_shadows);
}
-
void RasterizerCanvasGLES3::finalize() {
- glDeleteBuffers(1,&data.canvas_quad_vertices);
- glDeleteVertexArrays(1,&data.canvas_quad_array);
+ glDeleteBuffers(1, &data.canvas_quad_vertices);
+ glDeleteVertexArrays(1, &data.canvas_quad_array);
}
-RasterizerCanvasGLES3::RasterizerCanvasGLES3()
-{
-
+RasterizerCanvasGLES3::RasterizerCanvasGLES3() {
}
diff --git a/drivers/gles3/rasterizer_canvas_gles3.h b/drivers/gles3/rasterizer_canvas_gles3.h
index 1273e5f35..c90dcc7d6 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.h
+++ b/drivers/gles3/rasterizer_canvas_gles3.h
@@ -29,19 +29,16 @@
#ifndef RASTERIZERCANVASGLES3_H
#define RASTERIZERCANVASGLES3_H
-#include "servers/visual/rasterizer.h"
#include "rasterizer_storage_gles3.h"
+#include "servers/visual/rasterizer.h"
#include "shaders/canvas_shadow.glsl.h"
-
class RasterizerCanvasGLES3 : public RasterizerCanvas {
public:
-
struct CanvasItemUBO {
float projection_matrix[16];
float time[4];
-
};
struct Data {
@@ -63,7 +60,6 @@ public:
bool using_texture_rect;
-
RID current_tex;
RasterizerStorageGLES3::Texture *current_tex_ptr;
@@ -100,31 +96,27 @@ public:
RID_Owner<LightInternal> light_internal_owner;
virtual RID light_internal_create();
- virtual void light_internal_update(RID p_rid, Light* p_light);
+ virtual void light_internal_update(RID p_rid, Light *p_light);
virtual void light_internal_free(RID p_rid);
-
virtual void canvas_begin();
virtual void canvas_end();
_FORCE_INLINE_ void _set_texture_rect_mode(bool p_enable);
- _FORCE_INLINE_ RasterizerStorageGLES3::Texture* _bind_canvas_texture(const RID& p_texture);
-
- _FORCE_INLINE_ void _draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color* p_colors, const Vector2 *p_uvs);
- _FORCE_INLINE_ void _draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor);
- _FORCE_INLINE_ void _canvas_item_render_commands(Item *p_item,Item *current_clip,bool &reclip);
+ _FORCE_INLINE_ RasterizerStorageGLES3::Texture *_bind_canvas_texture(const RID &p_texture);
+ _FORCE_INLINE_ void _draw_gui_primitive(int p_points, const Vector2 *p_vertices, const Color *p_colors, const Vector2 *p_uvs);
+ _FORCE_INLINE_ void _draw_polygon(int p_vertex_count, const int *p_indices, const Vector2 *p_vertices, const Vector2 *p_uvs, const Color *p_colors, const RID &p_texture, bool p_singlecolor);
+ _FORCE_INLINE_ void _canvas_item_render_commands(Item *p_item, Item *current_clip, bool &reclip);
- virtual void canvas_render_items(Item *p_item_list,int p_z,const Color& p_modulate,Light *p_light);
- virtual void canvas_debug_viewport_shadows(Light* p_lights_with_shadow);
-
- virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D& p_light_xform, int p_light_mask,float p_near, float p_far, LightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
+ virtual void canvas_render_items(Item *p_item_list, int p_z, const Color &p_modulate, Light *p_light);
+ virtual void canvas_debug_viewport_shadows(Light *p_lights_with_shadow);
+ virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders, CameraMatrix *p_xform_cache);
virtual void reset_canvas();
- void draw_generic_textured_rect(const Rect2& p_rect, const Rect2& p_src);
-
+ void draw_generic_textured_rect(const Rect2 &p_rect, const Rect2 &p_src);
void initialize();
void finalize();
diff --git a/drivers/gles3/rasterizer_gles3.cpp b/drivers/gles3/rasterizer_gles3.cpp
index 05558a39b..b6cb57d68 100644
--- a/drivers/gles3/rasterizer_gles3.cpp
+++ b/drivers/gles3/rasterizer_gles3.cpp
@@ -28,9 +28,9 @@
/*************************************************************************/
#include "rasterizer_gles3.h"
-#include "os/os.h"
-#include "global_config.h"
#include "gl_context/context_gl.h"
+#include "global_config.h"
+#include "os/os.h"
#include <string.h>
RasterizerStorage *RasterizerGLES3::get_storage() {
@@ -77,63 +77,60 @@ RasterizerScene *RasterizerGLES3::get_scene() {
#define GLAPIENTRY
#endif
-static void GLAPIENTRY _gl_debug_print(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const GLvoid *userParam)
-{
+static void GLAPIENTRY _gl_debug_print(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
- if (type==_EXT_DEBUG_TYPE_OTHER_ARB)
+ if (type == _EXT_DEBUG_TYPE_OTHER_ARB)
return;
print_line("mesege");
char debSource[256], debType[256], debSev[256];
- if(source == _EXT_DEBUG_SOURCE_API_ARB)
- strcpy(debSource, "OpenGL");
- else if(source == _EXT_DEBUG_SOURCE_WINDOW_SYSTEM_ARB)
- strcpy(debSource, "Windows");
- else if(source == _EXT_DEBUG_SOURCE_SHADER_COMPILER_ARB)
- strcpy(debSource, "Shader Compiler");
- else if(source == _EXT_DEBUG_SOURCE_THIRD_PARTY_ARB)
- strcpy(debSource, "Third Party");
- else if(source == _EXT_DEBUG_SOURCE_APPLICATION_ARB)
- strcpy(debSource, "Application");
- else if(source == _EXT_DEBUG_SOURCE_OTHER_ARB)
- strcpy(debSource, "Other");
+ if (source == _EXT_DEBUG_SOURCE_API_ARB)
+ strcpy(debSource, "OpenGL");
+ else if (source == _EXT_DEBUG_SOURCE_WINDOW_SYSTEM_ARB)
+ strcpy(debSource, "Windows");
+ else if (source == _EXT_DEBUG_SOURCE_SHADER_COMPILER_ARB)
+ strcpy(debSource, "Shader Compiler");
+ else if (source == _EXT_DEBUG_SOURCE_THIRD_PARTY_ARB)
+ strcpy(debSource, "Third Party");
+ else if (source == _EXT_DEBUG_SOURCE_APPLICATION_ARB)
+ strcpy(debSource, "Application");
+ else if (source == _EXT_DEBUG_SOURCE_OTHER_ARB)
+ strcpy(debSource, "Other");
- if(type == _EXT_DEBUG_TYPE_ERROR_ARB)
- strcpy(debType, "Error");
- else if(type == _EXT_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB)
- strcpy(debType, "Deprecated behavior");
- else if(type == _EXT_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB)
- strcpy(debType, "Undefined behavior");
- else if(type == _EXT_DEBUG_TYPE_PORTABILITY_ARB)
- strcpy(debType, "Portability");
- else if(type == _EXT_DEBUG_TYPE_PERFORMANCE_ARB)
- strcpy(debType, "Performance");
- else if(type == _EXT_DEBUG_TYPE_OTHER_ARB)
- strcpy(debType, "Other");
+ if (type == _EXT_DEBUG_TYPE_ERROR_ARB)
+ strcpy(debType, "Error");
+ else if (type == _EXT_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB)
+ strcpy(debType, "Deprecated behavior");
+ else if (type == _EXT_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB)
+ strcpy(debType, "Undefined behavior");
+ else if (type == _EXT_DEBUG_TYPE_PORTABILITY_ARB)
+ strcpy(debType, "Portability");
+ else if (type == _EXT_DEBUG_TYPE_PERFORMANCE_ARB)
+ strcpy(debType, "Performance");
+ else if (type == _EXT_DEBUG_TYPE_OTHER_ARB)
+ strcpy(debType, "Other");
- if(severity == _EXT_DEBUG_SEVERITY_HIGH_ARB)
- strcpy(debSev, "High");
- else if(severity == _EXT_DEBUG_SEVERITY_MEDIUM_ARB)
- strcpy(debSev, "Medium");
- else if(severity == _EXT_DEBUG_SEVERITY_LOW_ARB)
- strcpy(debSev, "Low");
+ if (severity == _EXT_DEBUG_SEVERITY_HIGH_ARB)
+ strcpy(debSev, "High");
+ else if (severity == _EXT_DEBUG_SEVERITY_MEDIUM_ARB)
+ strcpy(debSev, "Medium");
+ else if (severity == _EXT_DEBUG_SEVERITY_LOW_ARB)
+ strcpy(debSev, "Low");
- String output = String()+ "GL ERROR: Source: " + debSource + "\tType: " + debType + "\tID: " + itos(id) + "\tSeverity: " + debSev + "\tMessage: " + message;
+ String output = String() + "GL ERROR: Source: " + debSource + "\tType: " + debType + "\tID: " + itos(id) + "\tSeverity: " + debSev + "\tMessage: " + message;
ERR_PRINTS(output);
-
}
-
typedef void (*DEBUGPROCARB)(GLenum source,
- GLenum type,
- GLuint id,
- GLenum severity,
- GLsizei length,
- const char* message,
- const void* userParam);
+ GLenum type,
+ GLuint id,
+ GLenum severity,
+ GLsizei length,
+ const char *message,
+ const void *userParam);
-typedef void (* DebugMessageCallbackARB) (DEBUGPROCARB callback, const void *userParam);
+typedef void (*DebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userParam);
void RasterizerGLES3::initialize() {
@@ -143,30 +140,30 @@ void RasterizerGLES3::initialize() {
#ifdef GLEW_ENABLED
GLuint res = glewInit();
- ERR_FAIL_COND(res!=GLEW_OK);
+ ERR_FAIL_COND(res != GLEW_OK);
if (OS::get_singleton()->is_stdout_verbose()) {
- print_line(String("GLES2: Using GLEW ") + (const char*) glewGetString(GLEW_VERSION));
+ print_line(String("GLES2: Using GLEW ") + (const char *)glewGetString(GLEW_VERSION));
}
// Check for GL 2.1 compatibility, if not bail out
if (!glewIsSupported("GL_VERSION_3_0")) {
ERR_PRINT("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
- "Try a drivers update, buy a new GPU or try software rendering on Linux; Godot will now crash with a segmentation fault.");
+ "Try a drivers update, buy a new GPU or try software rendering on Linux; Godot will now crash with a segmentation fault.");
OS::get_singleton()->alert("Your system's graphic drivers seem not to support OpenGL 3.0+ / GLES 3.0, sorry :(\n"
- "Godot Engine will self-destruct as soon as you acknowledge this error message.",
- "Fatal error: Insufficient OpenGL / GLES drivers");
+ "Godot Engine will self-destruct as soon as you acknowledge this error message.",
+ "Fatal error: Insufficient OpenGL / GLES drivers");
// TODO: If it's even possible, we should stop the execution without segfault and memory leaks :)
}
#endif
#ifdef GLAD_ENABLED
- if(!gladLoadGL()) {
+ if (!gladLoadGL()) {
ERR_PRINT("Error initializing GLAD");
}
#ifdef __APPLE__
- // FIXME glDebugMessageCallbackARB does not seem to work on Mac OS X and opengl 3, this may be an issue with our opengl canvas..
+// FIXME glDebugMessageCallbackARB does not seem to work on Mac OS X and opengl 3, this may be an issue with our opengl canvas..
#else
glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(_gl_debug_print, NULL);
@@ -175,8 +172,7 @@ void RasterizerGLES3::initialize() {
#endif
-
-/* glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_ERROR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
+ /* glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_ERROR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PORTABILITY_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
@@ -194,114 +190,104 @@ void RasterizerGLES3::initialize() {
scene->initialize();
}
-void RasterizerGLES3::begin_frame(){
+void RasterizerGLES3::begin_frame() {
uint64_t tick = OS::get_singleton()->get_ticks_usec();
- double time_total = double(tick)/1000000.0;
+ double time_total = double(tick) / 1000000.0;
- storage->frame.time[0]=time_total;
- storage->frame.time[1]=Math::fmod(time_total,3600);
- storage->frame.time[2]=Math::fmod(time_total,900);
- storage->frame.time[3]=Math::fmod(time_total,60);
+ storage->frame.time[0] = time_total;
+ storage->frame.time[1] = Math::fmod(time_total, 3600);
+ storage->frame.time[2] = Math::fmod(time_total, 900);
+ storage->frame.time[3] = Math::fmod(time_total, 60);
storage->frame.count++;
- storage->frame.delta = double(tick-storage->frame.prev_tick)/1000000.0;
- if (storage->frame.prev_tick==0) {
+ storage->frame.delta = double(tick - storage->frame.prev_tick) / 1000000.0;
+ if (storage->frame.prev_tick == 0) {
//to avoid hiccups
- storage->frame.delta=0.001;
+ storage->frame.delta = 0.001;
}
- storage->frame.prev_tick=tick;
-
+ storage->frame.prev_tick = tick;
storage->update_dirty_resources();
-
- storage->info.render_object_count=0;
- storage->info.render_material_switch_count=0;
- storage->info.render_surface_switch_count=0;
- storage->info.render_shader_rebind_count=0;
- storage->info.render_vertices_count=0;
-
+ storage->info.render_object_count = 0;
+ storage->info.render_material_switch_count = 0;
+ storage->info.render_surface_switch_count = 0;
+ storage->info.render_shader_rebind_count = 0;
+ storage->info.render_vertices_count = 0;
scene->iteration();
-
-
-
-
}
-void RasterizerGLES3::set_current_render_target(RID p_render_target){
+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->fbo);
- print_line("unbind clear of: "+storage->frame.clear_request_color);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
+ print_line("unbind clear of: " + storage->frame.clear_request_color);
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 );
+ 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);
-
}
if (p_render_target.is_valid()) {
- RasterizerStorageGLES3::RenderTarget * rt = storage->render_target_owner.getornull(p_render_target);
+ RasterizerStorageGLES3::RenderTarget *rt = storage->render_target_owner.getornull(p_render_target);
if (!rt) {
- storage->frame.current_rt=NULL;
+ storage->frame.current_rt = NULL;
}
ERR_FAIL_COND(!rt);
- storage->frame.current_rt=rt;
- storage->frame.clear_request=false;
+ storage->frame.current_rt = rt;
+ storage->frame.clear_request = false;
- glViewport(0,0,rt->width,rt->height);
+ glViewport(0, 0, rt->width, rt->height);
} else {
- storage->frame.current_rt=NULL;
- storage->frame.clear_request=false;
- glViewport(0,0,OS::get_singleton()->get_window_size().width,OS::get_singleton()->get_window_size().height);
- glBindFramebuffer(GL_FRAMEBUFFER,RasterizerStorageGLES3::system_fbo);
+ storage->frame.current_rt = NULL;
+ storage->frame.clear_request = false;
+ glViewport(0, 0, OS::get_singleton()->get_window_size().width, OS::get_singleton()->get_window_size().height);
+ glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
}
}
void RasterizerGLES3::restore_render_target() {
- ERR_FAIL_COND(storage->frame.current_rt==NULL);
- RasterizerStorageGLES3::RenderTarget * rt = storage->frame.current_rt;
- glBindFramebuffer(GL_FRAMEBUFFER,rt->fbo);
- glViewport(0,0,rt->width,rt->height);
-
+ ERR_FAIL_COND(storage->frame.current_rt == NULL);
+ RasterizerStorageGLES3::RenderTarget *rt = storage->frame.current_rt;
+ glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
+ glViewport(0, 0, rt->width, rt->height);
}
-void RasterizerGLES3::clear_render_target(const Color& p_color) {
+void RasterizerGLES3::clear_render_target(const Color &p_color) {
ERR_FAIL_COND(!storage->frame.current_rt);
- storage->frame.clear_request=true;
- storage->frame.clear_request_color=p_color;
-
+ storage->frame.clear_request = true;
+ storage->frame.clear_request_color = p_color;
}
-void RasterizerGLES3::blit_render_target_to_screen(RID p_render_target,const Rect2& p_screen_rect,int p_screen){
+void RasterizerGLES3::blit_render_target_to_screen(RID p_render_target, const Rect2 &p_screen_rect, int p_screen) {
- ERR_FAIL_COND( storage->frame.current_rt );
+ ERR_FAIL_COND(storage->frame.current_rt);
RasterizerStorageGLES3::RenderTarget *rt = storage->render_target_owner.getornull(p_render_target);
ERR_FAIL_COND(!rt);
canvas->canvas_begin();
glDisable(GL_BLEND);
- glBindFramebuffer(GL_FRAMEBUFFER,RasterizerStorageGLES3::system_fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,rt->color);
- canvas->draw_generic_textured_rect(p_screen_rect,Rect2(0,0,1,-1));
- glBindTexture(GL_TEXTURE_2D,0);
+ glBindTexture(GL_TEXTURE_2D, rt->color);
+ canvas->draw_generic_textured_rect(p_screen_rect, Rect2(0, 0, 1, -1));
+ glBindTexture(GL_TEXTURE_2D, 0);
canvas->canvas_end();
}
-void RasterizerGLES3::end_frame(){
+void RasterizerGLES3::end_frame() {
#if 0
canvas->canvas_begin();
@@ -335,7 +321,7 @@ void RasterizerGLES3::end_frame(){
#endif
OS::get_singleton()->swap_buffers();
-/* print_line("objects: "+itos(storage->info.render_object_count));
+ /* print_line("objects: "+itos(storage->info.render_object_count));
print_line("material chages: "+itos(storage->info.render_material_switch_count));
print_line("surface changes: "+itos(storage->info.render_surface_switch_count));
print_line("shader changes: "+itos(storage->info.render_shader_rebind_count));
@@ -343,45 +329,38 @@ void RasterizerGLES3::end_frame(){
*/
}
-void RasterizerGLES3::finalize(){
+void RasterizerGLES3::finalize() {
storage->finalize();
canvas->finalize();
}
-
Rasterizer *RasterizerGLES3::_create_current() {
- return memnew( RasterizerGLES3 );
+ return memnew(RasterizerGLES3);
}
void RasterizerGLES3::make_current() {
- _create_func=_create_current;
+ _create_func = _create_current;
}
-
void RasterizerGLES3::register_config() {
- GLOBAL_DEF("rendering/gles3/render_architecture",0);
- GlobalConfig::get_singleton()->set_custom_property_info("rendering/gles3/render_architecture",PropertyInfo(Variant::INT,"",PROPERTY_HINT_ENUM,"Desktop,Mobile"));
- GLOBAL_DEF("rendering/quality/use_nearest_mipmap_filter",false);
- GLOBAL_DEF("rendering/quality/anisotropic_filter_level",4.0);
-
+ GLOBAL_DEF("rendering/gles3/render_architecture", 0);
+ GlobalConfig::get_singleton()->set_custom_property_info("rendering/gles3/render_architecture", PropertyInfo(Variant::INT, "", PROPERTY_HINT_ENUM, "Desktop,Mobile"));
+ GLOBAL_DEF("rendering/quality/use_nearest_mipmap_filter", false);
+ GLOBAL_DEF("rendering/quality/anisotropic_filter_level", 4.0);
}
-RasterizerGLES3::RasterizerGLES3()
-{
-
- storage = memnew( RasterizerStorageGLES3 );
- canvas = memnew( RasterizerCanvasGLES3 );
- scene = memnew( RasterizerSceneGLES3 );
- canvas->storage=storage;
- storage->canvas=canvas;
- scene->storage=storage;
- storage->scene=scene;
-
-
+RasterizerGLES3::RasterizerGLES3() {
+ storage = memnew(RasterizerStorageGLES3);
+ canvas = memnew(RasterizerCanvasGLES3);
+ scene = memnew(RasterizerSceneGLES3);
+ canvas->storage = storage;
+ storage->canvas = canvas;
+ scene->storage = storage;
+ storage->scene = scene;
}
RasterizerGLES3::~RasterizerGLES3() {
diff --git a/drivers/gles3/rasterizer_gles3.h b/drivers/gles3/rasterizer_gles3.h
index 21e16b3bb..823f39ae8 100644
--- a/drivers/gles3/rasterizer_gles3.h
+++ b/drivers/gles3/rasterizer_gles3.h
@@ -29,11 +29,10 @@
#ifndef RASTERIZERGLES3_H
#define RASTERIZERGLES3_H
-#include "servers/visual/rasterizer.h"
-#include "rasterizer_storage_gles3.h"
#include "rasterizer_canvas_gles3.h"
#include "rasterizer_scene_gles3.h"
-
+#include "rasterizer_storage_gles3.h"
+#include "servers/visual/rasterizer.h"
class RasterizerGLES3 : public Rasterizer {
@@ -44,7 +43,6 @@ class RasterizerGLES3 : public Rasterizer {
RasterizerSceneGLES3 *scene;
public:
-
virtual RasterizerStorage *get_storage();
virtual RasterizerCanvas *get_canvas();
virtual RasterizerScene *get_scene();
@@ -53,14 +51,13 @@ public:
virtual void begin_frame();
virtual void set_current_render_target(RID p_render_target);
virtual void restore_render_target();
- virtual void clear_render_target(const Color& p_color);
- virtual void blit_render_target_to_screen(RID p_render_target,const Rect2& p_screen_rect,int p_screen=0);
+ virtual void clear_render_target(const Color &p_color);
+ virtual void blit_render_target_to_screen(RID p_render_target, const Rect2 &p_screen_rect, int p_screen = 0);
virtual void end_frame();
virtual void finalize();
static void make_current();
-
static void register_config();
RasterizerGLES3();
~RasterizerGLES3();
diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp
index f09e6ce90..b5d58ee99 100644
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -36,7 +36,7 @@
#define glClearDepth glClearDepthf
#endif
-static const GLenum _cube_side_enum[6]={
+static const GLenum _cube_side_enum[6] = {
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -47,53 +47,51 @@ static const GLenum _cube_side_enum[6]={
};
+static _FORCE_INLINE_ void store_transform2d(const Transform2D &p_mtx, float *p_array) {
-static _FORCE_INLINE_ void store_transform2d(const Transform2D& 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;
+ 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_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) {
+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++) {
+ for (int i = 0; i < 4; i++) {
+ for (int j = 0; j < 4; j++) {
- p_array[i*4+j]=p_mtx.matrix[i][j];
+ p_array[i * 4 + j] = p_mtx.matrix[i][j];
}
}
}
@@ -102,48 +100,47 @@ static _FORCE_INLINE_ void store_camera(const CameraMatrix& p_mtx, float* p_arra
RID RasterizerSceneGLES3::shadow_atlas_create() {
- ShadowAtlas *shadow_atlas = memnew( ShadowAtlas );
- shadow_atlas->fbo=0;
- shadow_atlas->depth=0;
- shadow_atlas->size=0;
- shadow_atlas->smallest_subdiv=0;
+ ShadowAtlas *shadow_atlas = memnew(ShadowAtlas);
+ shadow_atlas->fbo = 0;
+ shadow_atlas->depth = 0;
+ shadow_atlas->size = 0;
+ shadow_atlas->smallest_subdiv = 0;
- for(int i=0;i<4;i++) {
- shadow_atlas->size_order[i]=i;
+ for (int i = 0; i < 4; i++) {
+ shadow_atlas->size_order[i] = i;
}
-
return shadow_atlas_owner.make_rid(shadow_atlas);
}
-void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
+void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas, int p_size) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
ERR_FAIL_COND(!shadow_atlas);
- ERR_FAIL_COND(p_size<0);
+ ERR_FAIL_COND(p_size < 0);
p_size = nearest_power_of_2(p_size);
- if (p_size==shadow_atlas->size)
+ if (p_size == shadow_atlas->size)
return;
if (shadow_atlas->fbo) {
- glDeleteTextures(1,&shadow_atlas->depth);
- glDeleteFramebuffers(1,&shadow_atlas->fbo);
+ glDeleteTextures(1, &shadow_atlas->depth);
+ glDeleteFramebuffers(1, &shadow_atlas->fbo);
- shadow_atlas->depth=0;
- shadow_atlas->fbo=0;
+ shadow_atlas->depth = 0;
+ shadow_atlas->fbo = 0;
print_line("erasing atlas");
}
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
//clear subdivisions
shadow_atlas->quadrants[i].shadows.resize(0);
- shadow_atlas->quadrants[i].shadows.resize( 1<<shadow_atlas->quadrants[i].subdivision );
+ shadow_atlas->quadrants[i].shadows.resize(1 << shadow_atlas->quadrants[i].subdivision);
}
//erase shadow atlas reference from lights
- for (Map<RID,uint32_t>::Element *E=shadow_atlas->shadow_owners.front();E;E=E->next()) {
+ for (Map<RID, uint32_t>::Element *E = shadow_atlas->shadow_owners.front(); E; E = E->next()) {
LightInstance *li = light_instance_owner.getornull(E->key());
ERR_CONTINUE(!li);
li->shadow_atlases.erase(p_atlas);
@@ -152,9 +149,9 @@ void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
//clear owners
shadow_atlas->shadow_owners.clear();
- shadow_atlas->size=p_size;
+ shadow_atlas->size = p_size;
- if (shadow_atlas->size) {
+ if (shadow_atlas->size) {
glGenFramebuffers(1, &shadow_atlas->fbo);
glBindFramebuffer(GL_FRAMEBUFFER, shadow_atlas->fbo);
@@ -163,7 +160,7 @@ void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
glGenTextures(1, &shadow_atlas->depth);
glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, shadow_atlas->size, shadow_atlas->size, 0,
- GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+ GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -171,41 +168,37 @@ void RasterizerSceneGLES3::shadow_atlas_set_size(RID p_atlas,int p_size){
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_TEXTURE_2D, shadow_atlas->depth, 0);
+ GL_TEXTURE_2D, shadow_atlas->depth, 0);
- glViewport(0,0,shadow_atlas->size,shadow_atlas->size);
+ glViewport(0, 0, shadow_atlas->size, shadow_atlas->size);
glClearDepth(0.0f);
glClear(GL_DEPTH_BUFFER_BIT);
- glBindFramebuffer(GL_FRAMEBUFFER,0);
-
-
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}
-
-void RasterizerSceneGLES3::shadow_atlas_set_quadrant_subdivision(RID p_atlas,int p_quadrant,int p_subdivision){
+void RasterizerSceneGLES3::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
ERR_FAIL_COND(!shadow_atlas);
- ERR_FAIL_INDEX(p_quadrant,4);
- ERR_FAIL_INDEX(p_subdivision,16384);
-
+ ERR_FAIL_INDEX(p_quadrant, 4);
+ ERR_FAIL_INDEX(p_subdivision, 16384);
uint32_t subdiv = nearest_power_of_2(p_subdivision);
- if (subdiv&0xaaaaaaaa) { //sqrt(subdiv) must be integer
- subdiv<<=1;
+ if (subdiv & 0xaaaaaaaa) { //sqrt(subdiv) must be integer
+ subdiv <<= 1;
}
- subdiv=int(Math::sqrt((float)subdiv));
+ subdiv = int(Math::sqrt((float)subdiv));
//obtain the number that will be x*x
- if (shadow_atlas->quadrants[p_quadrant].subdivision==subdiv)
+ if (shadow_atlas->quadrants[p_quadrant].subdivision == subdiv)
return;
//erase all data from quadrant
- for(int i=0;i<shadow_atlas->quadrants[p_quadrant].shadows.size();i++) {
+ for (int i = 0; i < shadow_atlas->quadrants[p_quadrant].shadows.size(); i++) {
if (shadow_atlas->quadrants[p_quadrant].shadows[i].owner.is_valid()) {
shadow_atlas->shadow_owners.erase(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
@@ -216,51 +209,45 @@ void RasterizerSceneGLES3::shadow_atlas_set_quadrant_subdivision(RID p_atlas,int
}
shadow_atlas->quadrants[p_quadrant].shadows.resize(0);
- shadow_atlas->quadrants[p_quadrant].shadows.resize(subdiv*subdiv);
- shadow_atlas->quadrants[p_quadrant].subdivision=subdiv;
+ shadow_atlas->quadrants[p_quadrant].shadows.resize(subdiv * subdiv);
+ shadow_atlas->quadrants[p_quadrant].subdivision = subdiv;
//cache the smallest subdiv (for faster allocation in light update)
- shadow_atlas->smallest_subdiv=1<<30;
+ shadow_atlas->smallest_subdiv = 1 << 30;
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
if (shadow_atlas->quadrants[i].subdivision) {
- shadow_atlas->smallest_subdiv=MIN(shadow_atlas->smallest_subdiv,shadow_atlas->quadrants[i].subdivision);
+ shadow_atlas->smallest_subdiv = MIN(shadow_atlas->smallest_subdiv, shadow_atlas->quadrants[i].subdivision);
}
}
- if (shadow_atlas->smallest_subdiv==1<<30) {
- shadow_atlas->smallest_subdiv=0;
+ if (shadow_atlas->smallest_subdiv == 1 << 30) {
+ shadow_atlas->smallest_subdiv = 0;
}
//resort the size orders, simple bublesort for 4 elements..
- int swaps=0;
+ int swaps = 0;
do {
- swaps=0;
+ swaps = 0;
- for(int i=0;i<3;i++) {
- if (shadow_atlas->quadrants[shadow_atlas->size_order[i]].subdivision < shadow_atlas->quadrants[shadow_atlas->size_order[i+1]].subdivision) {
- SWAP(shadow_atlas->size_order[i],shadow_atlas->size_order[i+1]);
+ for (int i = 0; i < 3; i++) {
+ if (shadow_atlas->quadrants[shadow_atlas->size_order[i]].subdivision < shadow_atlas->quadrants[shadow_atlas->size_order[i + 1]].subdivision) {
+ SWAP(shadow_atlas->size_order[i], shadow_atlas->size_order[i + 1]);
swaps++;
}
}
- } while(swaps>0);
-
-
-
-
-
+ } while (swaps > 0);
}
-bool RasterizerSceneGLES3::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas,int *p_in_quadrants,int p_quadrant_count,int p_current_subdiv,uint64_t p_tick,int &r_quadrant,int &r_shadow) {
-
+bool RasterizerSceneGLES3::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow) {
- for(int i=p_quadrant_count-1;i>=0;i--) {
+ for (int i = p_quadrant_count - 1; i >= 0; i--) {
int qidx = p_in_quadrants[i];
- if (shadow_atlas->quadrants[qidx].subdivision==p_current_subdiv) {
+ if (shadow_atlas->quadrants[qidx].subdivision == p_current_subdiv) {
return false;
}
@@ -268,120 +255,113 @@ bool RasterizerSceneGLES3::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas,i
int sc = shadow_atlas->quadrants[qidx].shadows.size();
ShadowAtlas::Quadrant::Shadow *sarr = shadow_atlas->quadrants[qidx].shadows.ptr();
- int found_free_idx=-1; //found a free one
- int found_used_idx=-1; //found existing one, must steal it
+ int found_free_idx = -1; //found a free one
+ int found_used_idx = -1; //found existing one, must steal it
uint64_t min_pass; // pass of the existing one, try to use the least recently used one (LRU fashion)
- for(int j=0;j<sc;j++) {
+ for (int j = 0; j < sc; j++) {
if (!sarr[j].owner.is_valid()) {
- found_free_idx=j;
+ found_free_idx = j;
break;
}
LightInstance *sli = light_instance_owner.getornull(sarr[j].owner);
ERR_CONTINUE(!sli);
- if (sli->last_scene_pass!=scene_pass) {
+ if (sli->last_scene_pass != scene_pass) {
//was just allocated, don't kill it so soon, wait a bit..
- if (p_tick-sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec)
+ if (p_tick - sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec)
continue;
- if (found_used_idx==-1 || sli->last_scene_pass<min_pass) {
- found_used_idx=j;
- min_pass=sli->last_scene_pass;
+ if (found_used_idx == -1 || sli->last_scene_pass < min_pass) {
+ found_used_idx = j;
+ min_pass = sli->last_scene_pass;
}
}
}
- if (found_free_idx==-1 && found_used_idx==-1)
+ if (found_free_idx == -1 && found_used_idx == -1)
continue; //nothing found
- if (found_free_idx==-1 && found_used_idx!=-1) {
- found_free_idx=found_used_idx;
+ if (found_free_idx == -1 && found_used_idx != -1) {
+ found_free_idx = found_used_idx;
}
- r_quadrant=qidx;
- r_shadow=found_free_idx;
+ r_quadrant = qidx;
+ r_shadow = found_free_idx;
return true;
}
return false;
-
}
-
-bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version){
-
+bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
- ERR_FAIL_COND_V(!shadow_atlas,false);
+ ERR_FAIL_COND_V(!shadow_atlas, false);
LightInstance *li = light_instance_owner.getornull(p_light_intance);
- ERR_FAIL_COND_V(!li,false);
+ ERR_FAIL_COND_V(!li, false);
- if (shadow_atlas->size==0 || shadow_atlas->smallest_subdiv==0) {
+ if (shadow_atlas->size == 0 || shadow_atlas->smallest_subdiv == 0) {
return false;
}
- uint32_t quad_size = shadow_atlas->size>>1;
- int desired_fit = MIN(quad_size/shadow_atlas->smallest_subdiv,nearest_power_of_2(quad_size*p_coverage));
-
+ uint32_t quad_size = shadow_atlas->size >> 1;
+ int desired_fit = MIN(quad_size / shadow_atlas->smallest_subdiv, nearest_power_of_2(quad_size * p_coverage));
int valid_quadrants[4];
- int valid_quadrant_count=0;
- int best_size=-1; //best size found
- int best_subdiv=-1; //subdiv for the best size
+ int valid_quadrant_count = 0;
+ int best_size = -1; //best size found
+ int best_subdiv = -1; //subdiv for the best size
//find the quadrants this fits into, and the best possible size it can fit into
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
int q = shadow_atlas->size_order[i];
int sd = shadow_atlas->quadrants[q].subdivision;
- if (sd==0)
+ if (sd == 0)
continue; //unused
int max_fit = quad_size / sd;
- if (best_size!=-1 && max_fit>best_size)
+ if (best_size != -1 && max_fit > best_size)
break; //too large
- valid_quadrants[valid_quadrant_count++]=q;
- best_subdiv=sd;
+ valid_quadrants[valid_quadrant_count++] = q;
+ best_subdiv = sd;
- if (max_fit>=desired_fit) {
- best_size=max_fit;
+ if (max_fit >= desired_fit) {
+ best_size = max_fit;
}
}
- ERR_FAIL_COND_V(valid_quadrant_count==0,false);
+ ERR_FAIL_COND_V(valid_quadrant_count == 0, false);
uint64_t tick = OS::get_singleton()->get_ticks_msec();
-
//see if it already exists
if (shadow_atlas->shadow_owners.has(p_light_intance)) {
//it does!
uint32_t key = shadow_atlas->shadow_owners[p_light_intance];
- uint32_t q = (key>>ShadowAtlas::QUADRANT_SHIFT)&0x3;
- uint32_t s = key&ShadowAtlas::SHADOW_INDEX_MASK;
-
- bool should_realloc=shadow_atlas->quadrants[q].subdivision!=best_subdiv && (shadow_atlas->quadrants[q].shadows[s].alloc_tick-tick > shadow_atlas_realloc_tolerance_msec);
- bool should_redraw=shadow_atlas->quadrants[q].shadows[s].version!=p_light_version;
-
+ uint32_t q = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
+ uint32_t s = key & ShadowAtlas::SHADOW_INDEX_MASK;
+ bool should_realloc = shadow_atlas->quadrants[q].subdivision != best_subdiv && (shadow_atlas->quadrants[q].shadows[s].alloc_tick - tick > shadow_atlas_realloc_tolerance_msec);
+ bool should_redraw = shadow_atlas->quadrants[q].shadows[s].version != p_light_version;
if (!should_realloc) {
- shadow_atlas->quadrants[q].shadows[s].version=p_light_version;
+ shadow_atlas->quadrants[q].shadows[s].version = p_light_version;
//already existing, see if it should redraw or it's just OK
return should_redraw;
}
- int new_quadrant,new_shadow;
+ int new_quadrant, new_shadow;
//find a better place
- if (_shadow_atlas_find_shadow(shadow_atlas,valid_quadrants,valid_quadrant_count,shadow_atlas->quadrants[q].subdivision,tick,new_quadrant,new_shadow)) {
+ if (_shadow_atlas_find_shadow(shadow_atlas, valid_quadrants, valid_quadrant_count, shadow_atlas->quadrants[q].subdivision, tick, new_quadrant, new_shadow)) {
//found a better place!
ShadowAtlas::Quadrant::Shadow *sh = &shadow_atlas->quadrants[new_quadrant].shadows[new_shadow];
if (sh->owner.is_valid()) {
@@ -392,18 +372,18 @@ bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_in
}
//erase previous
- shadow_atlas->quadrants[q].shadows[s].version=0;
- shadow_atlas->quadrants[q].shadows[s].owner=RID();
+ shadow_atlas->quadrants[q].shadows[s].version = 0;
+ shadow_atlas->quadrants[q].shadows[s].owner = RID();
- sh->owner=p_light_intance;
- sh->alloc_tick=tick;
- sh->version=p_light_version;
+ sh->owner = p_light_intance;
+ sh->alloc_tick = tick;
+ sh->version = p_light_version;
//make new key
- key=new_quadrant<<ShadowAtlas::QUADRANT_SHIFT;
- key|=new_shadow;
+ key = new_quadrant << ShadowAtlas::QUADRANT_SHIFT;
+ key |= new_shadow;
//update it in map
- shadow_atlas->shadow_owners[p_light_intance]=key;
+ shadow_atlas->shadow_owners[p_light_intance] = key;
//make it dirty, as it should redraw anyway
return true;
}
@@ -412,15 +392,15 @@ bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_in
//already existing, see if it should redraw or it's just OK
- shadow_atlas->quadrants[q].shadows[s].version=p_light_version;
+ shadow_atlas->quadrants[q].shadows[s].version = p_light_version;
return should_redraw;
}
- int new_quadrant,new_shadow;
+ int new_quadrant, new_shadow;
//find a better place
- if (_shadow_atlas_find_shadow(shadow_atlas,valid_quadrants,valid_quadrant_count,-1,tick,new_quadrant,new_shadow)) {
+ if (_shadow_atlas_find_shadow(shadow_atlas, valid_quadrants, valid_quadrant_count, -1, tick, new_quadrant, new_shadow)) {
//found a better place!
ShadowAtlas::Quadrant::Shadow *sh = &shadow_atlas->quadrants[new_quadrant].shadows[new_shadow];
if (sh->owner.is_valid()) {
@@ -430,15 +410,15 @@ bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_in
sli->shadow_atlases.erase(p_atlas);
}
- sh->owner=p_light_intance;
- sh->alloc_tick=tick;
- sh->version=p_light_version;
+ sh->owner = p_light_intance;
+ sh->alloc_tick = tick;
+ sh->version = p_light_version;
//make new key
- uint32_t key=new_quadrant<<ShadowAtlas::QUADRANT_SHIFT;
- key|=new_shadow;
+ uint32_t key = new_quadrant << ShadowAtlas::QUADRANT_SHIFT;
+ key |= new_shadow;
//update it in map
- shadow_atlas->shadow_owners[p_light_intance]=key;
+ shadow_atlas->shadow_owners[p_light_intance] = key;
//make it dirty, as it should redraw anyway
return true;
@@ -447,113 +427,106 @@ bool RasterizerSceneGLES3::shadow_atlas_update_light(RID p_atlas, RID p_light_in
//no place to allocate this light, apologies
return false;
-
-
-
-
}
void RasterizerSceneGLES3::set_directional_shadow_count(int p_count) {
- directional_shadow.light_count=p_count;
- directional_shadow.current_light=0;
+ directional_shadow.light_count = p_count;
+ directional_shadow.current_light = 0;
}
int RasterizerSceneGLES3::get_directional_light_shadow_size(RID p_light_intance) {
- ERR_FAIL_COND_V(directional_shadow.light_count==0,0);
+ ERR_FAIL_COND_V(directional_shadow.light_count == 0, 0);
int shadow_size;
- if (directional_shadow.light_count==1) {
+ if (directional_shadow.light_count == 1) {
shadow_size = directional_shadow.size;
} else {
- shadow_size = directional_shadow.size/2; //more than 4 not supported anyway
+ shadow_size = directional_shadow.size / 2; //more than 4 not supported anyway
}
LightInstance *light_instance = light_instance_owner.getornull(p_light_intance);
- ERR_FAIL_COND_V(!light_instance,0);
+ ERR_FAIL_COND_V(!light_instance, 0);
- switch(light_instance->light_ptr->directional_shadow_mode) {
- case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: break; //none
+ switch (light_instance->light_ptr->directional_shadow_mode) {
+ case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL:
+ break; //none
case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS:
- case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: shadow_size/=2; break;
+ case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: shadow_size /= 2; break;
}
return shadow_size;
-
}
//////////////////////////////////////////////////////
RID RasterizerSceneGLES3::reflection_atlas_create() {
- ReflectionAtlas *reflection_atlas = memnew( ReflectionAtlas );
- reflection_atlas->subdiv=0;
- reflection_atlas->color=0;
- reflection_atlas->size=0;
- for(int i=0;i<6;i++) {
- reflection_atlas->fbo[i]=0;
+ ReflectionAtlas *reflection_atlas = memnew(ReflectionAtlas);
+ reflection_atlas->subdiv = 0;
+ reflection_atlas->color = 0;
+ reflection_atlas->size = 0;
+ for (int i = 0; i < 6; i++) {
+ reflection_atlas->fbo[i] = 0;
}
return reflection_atlas_owner.make_rid(reflection_atlas);
}
-void RasterizerSceneGLES3::reflection_atlas_set_size(RID p_ref_atlas,int p_size) {
+void RasterizerSceneGLES3::reflection_atlas_set_size(RID p_ref_atlas, int p_size) {
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_ref_atlas);
ERR_FAIL_COND(!reflection_atlas);
int size = nearest_power_of_2(p_size);
- if (size==reflection_atlas->size)
+ if (size == reflection_atlas->size)
return;
if (reflection_atlas->size) {
- for(int i=0;i<6;i++) {
- glDeleteFramebuffers(1,&reflection_atlas->fbo[i]);
- reflection_atlas->fbo[i]=0;
+ for (int i = 0; i < 6; i++) {
+ glDeleteFramebuffers(1, &reflection_atlas->fbo[i]);
+ reflection_atlas->fbo[i] = 0;
}
- glDeleteTextures(1,&reflection_atlas->color);
- reflection_atlas->color=0;
+ glDeleteTextures(1, &reflection_atlas->color);
+ reflection_atlas->color = 0;
}
- reflection_atlas->size=size;
+ reflection_atlas->size = size;
- for(int i=0;i<reflection_atlas->reflections.size();i++) {
+ for (int i = 0; i < reflection_atlas->reflections.size(); i++) {
//erase probes reference to this
if (reflection_atlas->reflections[i].owner.is_valid()) {
ReflectionProbeInstance *reflection_probe_instance = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[i].owner);
- reflection_atlas->reflections[i].owner=RID();
+ reflection_atlas->reflections[i].owner = RID();
ERR_CONTINUE(!reflection_probe_instance);
- reflection_probe_instance->reflection_atlas_index=-1;
- reflection_probe_instance->atlas=RID();
- reflection_probe_instance->render_step=-1;
+ reflection_probe_instance->reflection_atlas_index = -1;
+ reflection_probe_instance->atlas = RID();
+ reflection_probe_instance->render_step = -1;
}
}
-
if (reflection_atlas->size) {
- bool use_float=true;
-
+ bool use_float = true;
- GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+ GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2;
GLenum format = GL_RGBA;
- GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
-
+ GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV;
// Create a texture for storing the color
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &reflection_atlas->color);
glBindTexture(GL_TEXTURE_2D, reflection_atlas->color);
- int mmsize=reflection_atlas->size;
+ int mmsize = reflection_atlas->size;
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glTexImage2D(GL_TEXTURE_2D, i, internal_format, mmsize, mmsize, 0,
- format, type, NULL);
+ format, type, NULL);
- mmsize>>=1;
+ mmsize >>= 1;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
@@ -564,194 +537,180 @@ 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);
- mmsize=reflection_atlas->size;
+ mmsize = reflection_atlas->size;
- for(int i=0;i<6;i++) {
+ 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);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, reflection_atlas->color, i);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
glDisable(GL_SCISSOR_TEST);
- glViewport(0,0,mmsize,mmsize);
- glClearColor(0,0,0,0);
+ glViewport(0, 0, mmsize, mmsize);
+ glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT); //it needs to be cleared, to avoid generating garbage
- mmsize>>=1;
-
+ mmsize >>= 1;
}
-
-
}
-
-
-
}
-
-void RasterizerSceneGLES3::reflection_atlas_set_subdivision(RID p_ref_atlas,int p_subdiv) {
+void RasterizerSceneGLES3::reflection_atlas_set_subdivision(RID p_ref_atlas, int p_subdiv) {
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_ref_atlas);
ERR_FAIL_COND(!reflection_atlas);
uint32_t subdiv = nearest_power_of_2(p_subdiv);
- if (subdiv&0xaaaaaaaa) { //sqrt(subdiv) must be integer
- subdiv<<=1;
+ if (subdiv & 0xaaaaaaaa) { //sqrt(subdiv) must be integer
+ subdiv <<= 1;
}
- subdiv=int(Math::sqrt((float)subdiv));
+ subdiv = int(Math::sqrt((float)subdiv));
- if (reflection_atlas->subdiv==subdiv)
+ if (reflection_atlas->subdiv == subdiv)
return;
-
if (subdiv) {
- for(int i=0;i<reflection_atlas->reflections.size();i++) {
+ for (int i = 0; i < reflection_atlas->reflections.size(); i++) {
//erase probes reference to this
if (reflection_atlas->reflections[i].owner.is_valid()) {
ReflectionProbeInstance *reflection_probe_instance = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[i].owner);
- reflection_atlas->reflections[i].owner=RID();
+ reflection_atlas->reflections[i].owner = RID();
ERR_CONTINUE(!reflection_probe_instance);
- reflection_probe_instance->reflection_atlas_index=-1;
- reflection_probe_instance->atlas=RID();
- reflection_probe_instance->render_step=-1;
+ reflection_probe_instance->reflection_atlas_index = -1;
+ reflection_probe_instance->atlas = RID();
+ reflection_probe_instance->render_step = -1;
}
}
}
- reflection_atlas->subdiv=subdiv;
+ reflection_atlas->subdiv = subdiv;
- reflection_atlas->reflections.resize(subdiv*subdiv);
+ reflection_atlas->reflections.resize(subdiv * subdiv);
}
-
////////////////////////////////////////////////////
RID RasterizerSceneGLES3::reflection_probe_instance_create(RID p_probe) {
RasterizerStorageGLES3::ReflectionProbe *probe = storage->reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!probe,RID());
+ ERR_FAIL_COND_V(!probe, RID());
- ReflectionProbeInstance *rpi = memnew( ReflectionProbeInstance );
+ ReflectionProbeInstance *rpi = memnew(ReflectionProbeInstance);
- rpi->probe_ptr=probe;
- rpi->self=reflection_probe_instance_owner.make_rid(rpi);
- rpi->probe=p_probe;
- rpi->reflection_atlas_index=-1;
- rpi->render_step=-1;
- rpi->last_pass=0;
+ rpi->probe_ptr = probe;
+ rpi->self = reflection_probe_instance_owner.make_rid(rpi);
+ rpi->probe = p_probe;
+ rpi->reflection_atlas_index = -1;
+ rpi->render_step = -1;
+ rpi->last_pass = 0;
return rpi->self;
}
-void RasterizerSceneGLES3::reflection_probe_instance_set_transform(RID p_instance,const Transform& p_transform) {
+void RasterizerSceneGLES3::reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
ERR_FAIL_COND(!rpi);
- rpi->transform=p_transform;
-
+ rpi->transform = p_transform;
}
void RasterizerSceneGLES3::reflection_probe_release_atlas_index(RID p_instance) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
ERR_FAIL_COND(!rpi);
- if (rpi->reflection_atlas_index==-1)
+ if (rpi->reflection_atlas_index == -1)
return;
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(rpi->atlas);
ERR_FAIL_COND(!reflection_atlas);
- ERR_FAIL_INDEX(rpi->reflection_atlas_index,reflection_atlas->reflections.size());
-
- ERR_FAIL_COND(reflection_atlas->reflections[rpi->reflection_atlas_index].owner!=rpi->self);
+ ERR_FAIL_INDEX(rpi->reflection_atlas_index, reflection_atlas->reflections.size());
- reflection_atlas->reflections[rpi->reflection_atlas_index].owner=RID();
+ ERR_FAIL_COND(reflection_atlas->reflections[rpi->reflection_atlas_index].owner != rpi->self);
- rpi->reflection_atlas_index=-1;
- rpi->atlas=RID();
- rpi->render_step=-1;
+ reflection_atlas->reflections[rpi->reflection_atlas_index].owner = RID();
+ rpi->reflection_atlas_index = -1;
+ rpi->atlas = RID();
+ rpi->render_step = -1;
}
bool RasterizerSceneGLES3::reflection_probe_instance_needs_redraw(RID p_instance) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
- ERR_FAIL_COND_V(!rpi,false);
+ ERR_FAIL_COND_V(!rpi, false);
- return rpi->reflection_atlas_index==-1 || rpi->probe_ptr->update_mode==VS::REFLECTION_PROBE_UPDATE_ALWAYS;
+ return rpi->reflection_atlas_index == -1 || rpi->probe_ptr->update_mode == VS::REFLECTION_PROBE_UPDATE_ALWAYS;
}
-bool RasterizerSceneGLES3::reflection_probe_instance_has_reflection(RID p_instance){
+bool RasterizerSceneGLES3::reflection_probe_instance_has_reflection(RID p_instance) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
- ERR_FAIL_COND_V(!rpi,false);
+ ERR_FAIL_COND_V(!rpi, false);
- return rpi->reflection_atlas_index!=-1;
+ return rpi->reflection_atlas_index != -1;
}
-bool RasterizerSceneGLES3::reflection_probe_instance_begin_render(RID p_instance,RID p_reflection_atlas) {
+bool RasterizerSceneGLES3::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
- ERR_FAIL_COND_V(!rpi,false);
+ ERR_FAIL_COND_V(!rpi, false);
- rpi->render_step=0;
+ rpi->render_step = 0;
- if (rpi->reflection_atlas_index!=-1) {
+ if (rpi->reflection_atlas_index != -1) {
return true; //got one already
}
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
- ERR_FAIL_COND_V(!reflection_atlas,false);
-
+ ERR_FAIL_COND_V(!reflection_atlas, false);
- if (reflection_atlas->size==0 || reflection_atlas->subdiv==0) {
+ if (reflection_atlas->size == 0 || reflection_atlas->subdiv == 0) {
return false;
}
-
- int best_free=-1;
- int best_used=-1;
+ int best_free = -1;
+ int best_used = -1;
uint64_t best_used_frame;
- for(int i=0;i<reflection_atlas->reflections.size();i++) {
- if (reflection_atlas->reflections[i].owner==RID()) {
- best_free=i;
+ for (int i = 0; i < reflection_atlas->reflections.size(); i++) {
+ if (reflection_atlas->reflections[i].owner == RID()) {
+ best_free = i;
break;
}
- if (rpi->render_step<0 && reflection_atlas->reflections[i].last_frame<storage->frame.count &&
- (best_used==-1 || reflection_atlas->reflections[i].last_frame<best_used_frame)) {
- best_used=i;
- best_used_frame=reflection_atlas->reflections[i].last_frame;
+ if (rpi->render_step < 0 && reflection_atlas->reflections[i].last_frame < storage->frame.count &&
+ (best_used == -1 || reflection_atlas->reflections[i].last_frame < best_used_frame)) {
+ best_used = i;
+ best_used_frame = reflection_atlas->reflections[i].last_frame;
}
}
- if (best_free==-1 && best_used==-1) {
- return false ;// sorry, can not do. Try again next frame.
+ if (best_free == -1 && best_used == -1) {
+ return false; // sorry, can not do. Try again next frame.
}
- if (best_free==-1) {
+ if (best_free == -1) {
//find best from what is used
- best_free=best_used;
+ best_free = best_used;
ReflectionProbeInstance *victim_rpi = reflection_probe_instance_owner.getornull(reflection_atlas->reflections[best_free].owner);
- ERR_FAIL_COND_V(!victim_rpi,false);
- victim_rpi->atlas=RID();
- victim_rpi->reflection_atlas_index=-1;
-
+ ERR_FAIL_COND_V(!victim_rpi, false);
+ victim_rpi->atlas = RID();
+ victim_rpi->reflection_atlas_index = -1;
}
- reflection_atlas->reflections[best_free].owner=p_instance;
- reflection_atlas->reflections[best_free].last_frame=storage->frame.count;
+ reflection_atlas->reflections[best_free].owner = p_instance;
+ reflection_atlas->reflections[best_free].last_frame = storage->frame.count;
- rpi->reflection_atlas_index=best_free;
- rpi->atlas=p_reflection_atlas;
- rpi->render_step=0;
+ rpi->reflection_atlas_index = best_free;
+ rpi->atlas = p_reflection_atlas;
+ rpi->render_step = 0;
return true;
}
@@ -759,303 +718,274 @@ bool RasterizerSceneGLES3::reflection_probe_instance_begin_render(RID p_instance
bool RasterizerSceneGLES3::reflection_probe_instance_postprocess_step(RID p_instance) {
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
- ERR_FAIL_COND_V(!rpi,true);
+ ERR_FAIL_COND_V(!rpi, true);
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(rpi->atlas);
- ERR_FAIL_COND_V(!reflection_atlas,false);
+ ERR_FAIL_COND_V(!reflection_atlas, false);
- ERR_FAIL_COND_V(rpi->render_step>=6,true);
+ ERR_FAIL_COND_V(rpi->render_step >= 6, true);
- glBindFramebuffer(GL_FRAMEBUFFER,reflection_atlas->fbo[rpi->render_step]);
+ glBindFramebuffer(GL_FRAMEBUFFER, reflection_atlas->fbo[rpi->render_step]);
state.cube_to_dp_shader.bind();
- int target_size=reflection_atlas->size/reflection_atlas->subdiv;
+ int target_size = reflection_atlas->size / reflection_atlas->subdiv;
- int cubemap_index=reflection_cubemaps.size()-1;
+ int cubemap_index = reflection_cubemaps.size() - 1;
- for(int i=reflection_cubemaps.size()-1;i>=0;i--) {
+ for (int i = reflection_cubemaps.size() - 1; i >= 0; i--) {
//find appropriate cubemap to render to
- if (reflection_cubemaps[i].size>target_size*2)
+ if (reflection_cubemaps[i].size > target_size * 2)
break;
- cubemap_index=i;
+ cubemap_index = i;
}
glDisable(GL_BLEND);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_CUBE_MAP,reflection_cubemaps[cubemap_index].cubemap);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, reflection_cubemaps[cubemap_index].cubemap);
glDisable(GL_CULL_FACE);
- storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true);
+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, true);
storage->shaders.cubemap_filter.bind();
int cell_size = reflection_atlas->size / reflection_atlas->subdiv;
- for(int i=0;i<rpi->render_step;i++) {
- cell_size>>=1; //mipmaps!
+ for (int i = 0; i < rpi->render_step; i++) {
+ cell_size >>= 1; //mipmaps!
}
int x = (rpi->reflection_atlas_index % reflection_atlas->subdiv) * cell_size;
int y = (rpi->reflection_atlas_index / reflection_atlas->subdiv) * cell_size;
- int width=cell_size;
- int height=cell_size;
+ int width = cell_size;
+ int height = cell_size;
- storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE,rpi->render_step==0);
- storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY,rpi->probe_ptr->update_mode==VS::REFLECTION_PROBE_UPDATE_ALWAYS);
- for(int i=0;i<2;i++) {
+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE, rpi->render_step == 0);
+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY, rpi->probe_ptr->update_mode == VS::REFLECTION_PROBE_UPDATE_ALWAYS);
+ for (int i = 0; i < 2; i++) {
- storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP,i>0);
- storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,rpi->render_step/5.0);
+ storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP, i > 0);
+ storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS, rpi->render_step / 5.0);
- uint32_t local_width=width,local_height=height;
- uint32_t local_x=x,local_y=y;
+ uint32_t local_width = width, local_height = height;
+ uint32_t local_x = x, local_y = y;
- local_height/=2;
- local_y+=i*local_height;
+ local_height /= 2;
+ local_y += i * local_height;
- glViewport(local_x,local_y,local_width,local_height);
+ glViewport(local_x, local_y, local_width, local_height);
_copy_screen();
}
- storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE,false);
- storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY,false);
-
+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DIRECT_WRITE, false);
+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::LOW_QUALITY, false);
rpi->render_step++;
- return rpi->render_step==6;
+ return rpi->render_step == 6;
}
/* ENVIRONMENT API */
-RID RasterizerSceneGLES3::environment_create(){
+RID RasterizerSceneGLES3::environment_create() {
-
- Environment *env = memnew( Environment );
+ Environment *env = memnew(Environment);
return environment_owner.make_rid(env);
}
-void RasterizerSceneGLES3::environment_set_background(RID p_env,VS::EnvironmentBG p_bg){
+void RasterizerSceneGLES3::environment_set_background(RID p_env, VS::EnvironmentBG p_bg) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->bg_mode=p_bg;
+ env->bg_mode = p_bg;
}
-void RasterizerSceneGLES3::environment_set_skybox(RID p_env, RID p_skybox){
+void RasterizerSceneGLES3::environment_set_skybox(RID p_env, RID p_skybox) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->skybox=p_skybox;
-
+ env->skybox = p_skybox;
}
-void RasterizerSceneGLES3::environment_set_skybox_scale(RID p_env,float p_scale) {
+void RasterizerSceneGLES3::environment_set_skybox_scale(RID p_env, float p_scale) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->skybox_scale=p_scale;
-
+ env->skybox_scale = p_scale;
}
-void RasterizerSceneGLES3::environment_set_bg_color(RID p_env,const Color& p_color){
+void RasterizerSceneGLES3::environment_set_bg_color(RID p_env, const Color &p_color) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->bg_color=p_color;
-
+ env->bg_color = p_color;
}
-void RasterizerSceneGLES3::environment_set_bg_energy(RID p_env,float p_energy) {
+void RasterizerSceneGLES3::environment_set_bg_energy(RID p_env, float p_energy) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->bg_energy=p_energy;
-
+ env->bg_energy = p_energy;
}
-void RasterizerSceneGLES3::environment_set_canvas_max_layer(RID p_env,int p_max_layer){
+void RasterizerSceneGLES3::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->canvas_max_layer=p_max_layer;
-
+ env->canvas_max_layer = p_max_layer;
}
-void RasterizerSceneGLES3::environment_set_ambient_light(RID p_env, const Color& p_color, float p_energy, float p_skybox_contribution){
+void RasterizerSceneGLES3::environment_set_ambient_light(RID p_env, const Color &p_color, float p_energy, float p_skybox_contribution) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->ambient_color=p_color;
- env->ambient_energy=p_energy;
- env->ambient_skybox_contribution=p_skybox_contribution;
-
+ env->ambient_color = p_color;
+ env->ambient_energy = p_energy;
+ env->ambient_skybox_contribution = p_skybox_contribution;
}
+void RasterizerSceneGLES3::environment_set_dof_blur_far(RID p_env, bool p_enable, float p_distance, float p_transition, float p_amount, VS::EnvironmentDOFBlurQuality p_quality) {
-
-void RasterizerSceneGLES3::environment_set_dof_blur_far(RID p_env,bool p_enable,float p_distance,float p_transition,float p_amount,VS::EnvironmentDOFBlurQuality p_quality){
-
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->dof_blur_far_enabled=p_enable;
- env->dof_blur_far_distance=p_distance;
- env->dof_blur_far_transition=p_transition;
- env->dof_blur_far_amount=p_amount;
- env->dof_blur_far_quality=p_quality;
-
-
+ env->dof_blur_far_enabled = p_enable;
+ env->dof_blur_far_distance = p_distance;
+ env->dof_blur_far_transition = p_transition;
+ env->dof_blur_far_amount = p_amount;
+ env->dof_blur_far_quality = p_quality;
}
-void RasterizerSceneGLES3::environment_set_dof_blur_near(RID p_env,bool p_enable,float p_distance,float p_transition,float p_amount,VS::EnvironmentDOFBlurQuality p_quality){
+void RasterizerSceneGLES3::environment_set_dof_blur_near(RID p_env, bool p_enable, float p_distance, float p_transition, float p_amount, VS::EnvironmentDOFBlurQuality p_quality) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->dof_blur_near_enabled=p_enable;
- env->dof_blur_near_distance=p_distance;
- env->dof_blur_near_transition=p_transition;
- env->dof_blur_near_amount=p_amount;
- env->dof_blur_near_quality=p_quality;
-
-
+ env->dof_blur_near_enabled = p_enable;
+ env->dof_blur_near_distance = p_distance;
+ env->dof_blur_near_transition = p_transition;
+ env->dof_blur_near_amount = p_amount;
+ env->dof_blur_near_quality = p_quality;
}
void RasterizerSceneGLES3::environment_set_glow(RID p_env, bool p_enable, int p_level_flags, float p_intensity, float p_strength, float p_bloom_treshold, VS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_treshold, float p_hdr_bleed_scale, bool p_bicubic_upscale) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->glow_enabled=p_enable;
- env->glow_levels=p_level_flags;
- env->glow_intensity=p_intensity;
- env->glow_strength=p_strength;
- env->glow_bloom=p_bloom_treshold;
- env->glow_blend_mode=p_blend_mode;
- env->glow_hdr_bleed_treshold=p_hdr_bleed_treshold;
- env->glow_hdr_bleed_scale=p_hdr_bleed_scale;
- env->glow_bicubic_upscale=p_bicubic_upscale;
-
+ env->glow_enabled = p_enable;
+ env->glow_levels = p_level_flags;
+ env->glow_intensity = p_intensity;
+ env->glow_strength = p_strength;
+ env->glow_bloom = p_bloom_treshold;
+ env->glow_blend_mode = p_blend_mode;
+ env->glow_hdr_bleed_treshold = p_hdr_bleed_treshold;
+ env->glow_hdr_bleed_scale = p_hdr_bleed_scale;
+ env->glow_bicubic_upscale = p_bicubic_upscale;
}
-void RasterizerSceneGLES3::environment_set_fog(RID p_env,bool p_enable,float p_begin,float p_end,RID p_gradient_texture){
-
+void RasterizerSceneGLES3::environment_set_fog(RID p_env, bool p_enable, float p_begin, float p_end, RID p_gradient_texture) {
}
-void RasterizerSceneGLES3::environment_set_ssr(RID p_env,bool p_enable, int p_max_steps,float p_accel,float p_fade,float p_depth_tolerance,bool p_smooth,bool p_roughness) {
+void RasterizerSceneGLES3::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_accel, float p_fade, float p_depth_tolerance, bool p_smooth, bool p_roughness) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->ssr_enabled=p_enable;
- env->ssr_max_steps=p_max_steps;
- env->ssr_accel=p_accel;
- env->ssr_fade=p_fade;
- env->ssr_depth_tolerance=p_depth_tolerance;
- env->ssr_smooth=p_smooth;
- env->ssr_roughness=p_roughness;
-
+ env->ssr_enabled = p_enable;
+ env->ssr_max_steps = p_max_steps;
+ env->ssr_accel = p_accel;
+ env->ssr_fade = p_fade;
+ env->ssr_depth_tolerance = p_depth_tolerance;
+ env->ssr_smooth = p_smooth;
+ env->ssr_roughness = p_roughness;
}
+void RasterizerSceneGLES3::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_radius2, float p_intensity2, float p_bias, float p_light_affect, const Color &p_color, bool p_blur) {
-void RasterizerSceneGLES3::environment_set_ssao(RID p_env,bool p_enable, float p_radius, float p_intensity, float p_radius2, float p_intensity2, float p_bias, float p_light_affect,const Color &p_color,bool p_blur) {
-
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
- env->ssao_enabled=p_enable;
- env->ssao_radius=p_radius;
- env->ssao_intensity=p_intensity;
- env->ssao_radius2=p_radius2;
- env->ssao_intensity2=p_intensity2;
- env->ssao_bias=p_bias;
- env->ssao_light_affect=p_light_affect;
- env->ssao_color=p_color;
- env->ssao_filter=p_blur;
-
+ env->ssao_enabled = p_enable;
+ env->ssao_radius = p_radius;
+ env->ssao_intensity = p_intensity;
+ env->ssao_radius2 = p_radius2;
+ env->ssao_intensity2 = p_intensity2;
+ env->ssao_bias = p_bias;
+ env->ssao_light_affect = p_light_affect;
+ env->ssao_color = p_color;
+ env->ssao_filter = p_blur;
}
-void RasterizerSceneGLES3::environment_set_tonemap(RID p_env,VS::EnvironmentToneMapper p_tone_mapper,float p_exposure,float p_white,bool p_auto_exposure,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,float p_auto_exp_scale) {
+void RasterizerSceneGLES3::environment_set_tonemap(RID p_env, VS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white, bool p_auto_exposure, float p_min_luminance, float p_max_luminance, float p_auto_exp_speed, float p_auto_exp_scale) {
- Environment *env=environment_owner.getornull(p_env);
+ Environment *env = environment_owner.getornull(p_env);
ERR_FAIL_COND(!env);
-
- env->tone_mapper=p_tone_mapper;
- env->tone_mapper_exposure=p_exposure;
- env->tone_mapper_exposure_white=p_white;
- env->auto_exposure=p_auto_exposure;
- env->auto_exposure_speed=p_auto_exp_speed;
- env->auto_exposure_min=p_min_luminance;
- env->auto_exposure_max=p_max_luminance;
- env->auto_exposure_grey=p_auto_exp_scale;
-
+ env->tone_mapper = p_tone_mapper;
+ env->tone_mapper_exposure = p_exposure;
+ env->tone_mapper_exposure_white = p_white;
+ env->auto_exposure = p_auto_exposure;
+ env->auto_exposure_speed = p_auto_exp_speed;
+ env->auto_exposure_min = p_min_luminance;
+ env->auto_exposure_max = p_max_luminance;
+ env->auto_exposure_grey = p_auto_exp_scale;
}
-
-void RasterizerSceneGLES3::environment_set_adjustment(RID p_env,bool p_enable,float p_brightness,float p_contrast,float p_saturation,RID p_ramp) {
-
-
+void RasterizerSceneGLES3::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, RID p_ramp) {
}
-
RID RasterizerSceneGLES3::light_instance_create(RID p_light) {
+ LightInstance *light_instance = memnew(LightInstance);
- LightInstance *light_instance = memnew( LightInstance );
+ light_instance->last_pass = 0;
+ light_instance->last_scene_pass = 0;
+ light_instance->last_scene_shadow_pass = 0;
- light_instance->last_pass=0;
- light_instance->last_scene_pass=0;
- light_instance->last_scene_shadow_pass=0;
+ light_instance->light = p_light;
+ light_instance->light_ptr = storage->light_owner.getornull(p_light);
- light_instance->light=p_light;
- light_instance->light_ptr=storage->light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light_instance->light_ptr, RID());
- ERR_FAIL_COND_V(!light_instance->light_ptr,RID());
-
- light_instance->self=light_instance_owner.make_rid(light_instance);
+ light_instance->self = light_instance_owner.make_rid(light_instance);
return light_instance->self;
}
-void RasterizerSceneGLES3::light_instance_set_transform(RID p_light_instance,const Transform& p_transform){
+void RasterizerSceneGLES3::light_instance_set_transform(RID p_light_instance, const Transform &p_transform) {
LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
ERR_FAIL_COND(!light_instance);
- light_instance->transform=p_transform;
+ light_instance->transform = p_transform;
}
-void RasterizerSceneGLES3::light_instance_set_shadow_transform(RID p_light_instance,const CameraMatrix& p_projection,const Transform& p_transform,float p_far,float p_split,int p_pass) {
+void RasterizerSceneGLES3::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass) {
LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
ERR_FAIL_COND(!light_instance);
- if (light_instance->light_ptr->type!=VS::LIGHT_DIRECTIONAL) {
- p_pass=0;
+ if (light_instance->light_ptr->type != VS::LIGHT_DIRECTIONAL) {
+ p_pass = 0;
}
- ERR_FAIL_INDEX(p_pass,4);
-
- light_instance->shadow_transform[p_pass].camera=p_projection;
- light_instance->shadow_transform[p_pass].transform=p_transform;
- light_instance->shadow_transform[p_pass].farplane=p_far;
- light_instance->shadow_transform[p_pass].split=p_split;
+ ERR_FAIL_INDEX(p_pass, 4);
+ light_instance->shadow_transform[p_pass].camera = p_projection;
+ light_instance->shadow_transform[p_pass].transform = p_transform;
+ light_instance->shadow_transform[p_pass].farplane = p_far;
+ light_instance->shadow_transform[p_pass].split = p_split;
}
-
void RasterizerSceneGLES3::light_instance_mark_visible(RID p_light_instance) {
LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
ERR_FAIL_COND(!light_instance);
- light_instance->last_scene_pass=scene_pass;
+ light_instance->last_scene_pass = scene_pass;
}
-
//////////////////////
RID RasterizerSceneGLES3::gi_probe_instance_create() {
@@ -1069,66 +999,63 @@ void RasterizerSceneGLES3::gi_probe_instance_set_light_data(RID p_probe, RID p_b
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);
+ 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);
if (gipd) {
- gipi->tex_cache=gipd->tex_id;
- gipi->cell_size_cache.x=1.0/gipd->width;
- gipi->cell_size_cache.y=1.0/gipd->height;
- gipi->cell_size_cache.z=1.0/gipd->depth;
+ gipi->tex_cache = gipd->tex_id;
+ gipi->cell_size_cache.x = 1.0 / gipd->width;
+ gipi->cell_size_cache.y = 1.0 / gipd->height;
+ gipi->cell_size_cache.z = 1.0 / gipd->depth;
}
}
}
-void RasterizerSceneGLES3::gi_probe_instance_set_transform_to_data(RID p_probe,const Transform& p_xform) {
+void RasterizerSceneGLES3::gi_probe_instance_set_transform_to_data(RID p_probe, const Transform &p_xform) {
GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
ERR_FAIL_COND(!gipi);
- gipi->transform_to_data=p_xform;
-
+ gipi->transform_to_data = p_xform;
}
-void RasterizerSceneGLES3::gi_probe_instance_set_bounds(RID p_probe,const Vector3& p_bounds) {
+void RasterizerSceneGLES3::gi_probe_instance_set_bounds(RID p_probe, const Vector3 &p_bounds) {
GIProbeInstance *gipi = gi_probe_instance_owner.getornull(p_probe);
ERR_FAIL_COND(!gipi);
- gipi->bounds=p_bounds;
-
+ gipi->bounds = p_bounds;
}
////////////////////////////
////////////////////////////
////////////////////////////
-bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass) {
+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) {
+ if (p_material->shader->spatial.cull_mode == RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_DISABLED) {
glDisable(GL_CULL_FACE);
} else {
glEnable(GL_CULL_FACE);
}
- if (state.current_line_width!=p_material->line_width) {
+ if (state.current_line_width != p_material->line_width) {
//glLineWidth(MAX(p_material->line_width,1.0));
- state.current_line_width=p_material->line_width;
+ state.current_line_width = p_material->line_width;
}
- if (state.current_depth_test!=(!p_material->shader->spatial.ontop)) {
+ if (state.current_depth_test != (!p_material->shader->spatial.ontop)) {
if (p_material->shader->spatial.ontop) {
glDisable(GL_DEPTH_TEST);
} else {
glEnable(GL_DEPTH_TEST);
-
}
- state.current_depth_test=!p_material->shader->spatial.ontop;
+ state.current_depth_test = !p_material->shader->spatial.ontop;
}
- if (state.current_depth_draw!=p_material->shader->spatial.depth_draw_mode) {
- switch(p_material->shader->spatial.depth_draw_mode) {
+ if (state.current_depth_draw != p_material->shader->spatial.depth_draw_mode) {
+ switch (p_material->shader->spatial.depth_draw_mode) {
case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS:
case RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_OPAQUE: {
@@ -1142,12 +1069,12 @@ bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_m
} break;
}
- state.current_depth_draw=p_material->shader->spatial.depth_draw_mode;
+ state.current_depth_draw = p_material->shader->spatial.depth_draw_mode;
}
- //glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
+//glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
- /*
+/*
if (p_material->flags[VS::MATERIAL_FLAG_WIREFRAME])
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
else
@@ -1200,54 +1127,49 @@ bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_m
#endif
//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);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 1, p_material->ubo_id);
}
-
-
int tc = p_material->textures.size();
- RID* textures = p_material->textures.ptr();
- ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = p_material->shader->texture_hints.ptr();
+ RID *textures = p_material->textures.ptr();
+ ShaderLanguage::ShaderNode::Uniform::Hint *texture_hints = p_material->shader->texture_hints.ptr();
- state.current_main_tex=0;
+ state.current_main_tex = 0;
- for(int i=0;i<tc;i++) {
+ for (int i = 0; i < tc; i++) {
- glActiveTexture(GL_TEXTURE0+i);
+ glActiveTexture(GL_TEXTURE0 + i);
GLenum target;
GLuint tex;
- RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
+ RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull(textures[i]);
if (!t) {
//check hints
- target=GL_TEXTURE_2D;
+ target = GL_TEXTURE_2D;
- switch(texture_hints[i]) {
+ switch (texture_hints[i]) {
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
- tex=storage->resources.black_tex;
+ tex = storage->resources.black_tex;
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
- tex=storage->resources.aniso_tex;
+ tex = storage->resources.aniso_tex;
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
- tex=storage->resources.normal_tex;
+ tex = storage->resources.normal_tex;
} break;
default: {
- tex=storage->resources.white_tex;
+ tex = storage->resources.white_tex;
} break;
}
-
} else {
#ifdef TOOLS_ENABLED
@@ -1257,15 +1179,15 @@ bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_m
#endif
if (storage->config.srgb_decode_supported) {
//if SRGB decode extension is present, simply switch the texture to whathever is needed
- bool must_srgb=false;
+ bool must_srgb = false;
- if (t->srgb && (texture_hints[i]==ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || texture_hints[i]==ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO)) {
- must_srgb=true;
+ if (t->srgb && (texture_hints[i] == ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || texture_hints[i] == ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO)) {
+ must_srgb = true;
}
- if (t->using_srgb!=must_srgb) {
+ if (t->using_srgb != must_srgb) {
if (must_srgb) {
- glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
+ glTexParameteri(t->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
#ifdef TOOLS_ENABLED
if (t->detect_srgb) {
t->detect_srgb(t->detect_srgb_ud);
@@ -1273,41 +1195,37 @@ bool RasterizerSceneGLES3::_setup_material(RasterizerStorageGLES3::Material* p_m
#endif
} else {
- glTexParameteri(t->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
+ glTexParameteri(t->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT);
}
- t->using_srgb=must_srgb;
+ t->using_srgb = must_srgb;
}
}
- target=t->target;
+ target = t->target;
tex = t->tex_id;
-
}
- glBindTexture(target,tex);
+ glBindTexture(target, tex);
- if (i==0) {
- state.current_main_tex=tex;
+ if (i == 0) {
+ state.current_main_tex = tex;
}
}
-
return rebind;
-
}
-
void RasterizerSceneGLES3::_setup_geometry(RenderList::Element *e) {
- switch(e->instance->base_type) {
+ switch (e->instance->base_type) {
case VS::INSTANCE_MESH: {
- RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+ RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface *>(e->geometry);
if (s->blend_shapes.size() && e->instance->blend_values.size()) {
//blend shapes, use transform feedback
- storage->mesh_render_blend_shapes(s,e->instance->blend_values.ptr());
+ storage->mesh_render_blend_shapes(s, e->instance->blend_values.ptr());
//rebind shader
state.scene_shader.bind();
} else {
@@ -1319,57 +1237,56 @@ void RasterizerSceneGLES3::_setup_geometry(RenderList::Element *e) {
case VS::INSTANCE_MULTIMESH: {
- RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh*>(e->owner);
- RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+ RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh *>(e->owner);
+ RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface *>(e->geometry);
glBindVertexArray(s->instancing_array_id); // use the instancing array ID
- glBindBuffer(GL_ARRAY_BUFFER,multi_mesh->buffer); //modify the buffer
+ glBindBuffer(GL_ARRAY_BUFFER, multi_mesh->buffer); //modify the buffer
- int stride = (multi_mesh->xform_floats+multi_mesh->color_floats)*4;
+ int stride = (multi_mesh->xform_floats + multi_mesh->color_floats) * 4;
glEnableVertexAttribArray(8);
- glVertexAttribPointer(8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+0);
- glVertexAttribDivisor(8,1);
+ glVertexAttribPointer(8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + 0);
+ glVertexAttribDivisor(8, 1);
glEnableVertexAttribArray(9);
- glVertexAttribPointer(9,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+4*4);
- glVertexAttribDivisor(9,1);
+ glVertexAttribPointer(9, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + 4 * 4);
+ glVertexAttribDivisor(9, 1);
int color_ofs;
- if (multi_mesh->transform_format==VS::MULTIMESH_TRANSFORM_3D) {
+ if (multi_mesh->transform_format == VS::MULTIMESH_TRANSFORM_3D) {
glEnableVertexAttribArray(10);
- glVertexAttribPointer(10,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+8*4);
- glVertexAttribDivisor(10,1);
- color_ofs=12*4;
+ glVertexAttribPointer(10, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + 8 * 4);
+ glVertexAttribDivisor(10, 1);
+ color_ofs = 12 * 4;
} else {
glDisableVertexAttribArray(10);
- glVertexAttrib4f(10,0,0,1,0);
- color_ofs=8*4;
+ glVertexAttrib4f(10, 0, 0, 1, 0);
+ color_ofs = 8 * 4;
}
- switch(multi_mesh->color_format) {
+ switch (multi_mesh->color_format) {
case VS::MULTIMESH_COLOR_NONE: {
glDisableVertexAttribArray(11);
- glVertexAttrib4f(11,1,1,1,1);
+ glVertexAttrib4f(11, 1, 1, 1, 1);
} break;
case VS::MULTIMESH_COLOR_8BIT: {
glEnableVertexAttribArray(11);
- glVertexAttribPointer(11,4,GL_UNSIGNED_BYTE,GL_TRUE,stride,((uint8_t*)NULL)+color_ofs);
- glVertexAttribDivisor(11,1);
+ glVertexAttribPointer(11, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, ((uint8_t *)NULL) + color_ofs);
+ glVertexAttribDivisor(11, 1);
} break;
case VS::MULTIMESH_COLOR_FLOAT: {
glEnableVertexAttribArray(11);
- glVertexAttribPointer(11,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)NULL)+color_ofs);
- glVertexAttribDivisor(11,1);
+ glVertexAttribPointer(11, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)NULL) + color_ofs);
+ glVertexAttribDivisor(11, 1);
} break;
}
} break;
}
-
}
-static const GLenum gl_primitive[]={
+static const GLenum gl_primitive[] = {
GL_POINTS,
GL_LINES,
GL_LINE_STRIP,
@@ -1379,63 +1296,53 @@ static const GLenum gl_primitive[]={
GL_TRIANGLE_FAN
};
-
-
void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
- switch(e->instance->base_type) {
+ switch (e->instance->base_type) {
case VS::INSTANCE_MESH: {
- RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
+ RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface *>(e->geometry);
- if (s->index_array_len>0) {
+ 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);
- glDrawElements(gl_primitive[s->primitive],s->index_array_len, (s->array_len>=(1<<16))?GL_UNSIGNED_INT:GL_UNSIGNED_SHORT,0);
-
- storage->info.render_vertices_count+=s->index_array_len;
+ storage->info.render_vertices_count += s->index_array_len;
} else {
- glDrawArrays(gl_primitive[s->primitive],0,s->array_len);
-
- storage->info.render_vertices_count+=s->array_len;
+ glDrawArrays(gl_primitive[s->primitive], 0, s->array_len);
+ storage->info.render_vertices_count += s->array_len;
}
-
-
-
} break;
case VS::INSTANCE_MULTIMESH: {
- RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh*>(e->owner);
- RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface*>(e->geometry);
-
- int amount = MAX(multi_mesh->size,multi_mesh->visible_instances);
+ RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh *>(e->owner);
+ RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface *>(e->geometry);
+ int amount = MAX(multi_mesh->size, multi_mesh->visible_instances);
+ if (s->index_array_len > 0) {
- if (s->index_array_len>0) {
+ glDrawElementsInstanced(gl_primitive[s->primitive], s->index_array_len, (s->array_len >= (1 << 16)) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0, amount);
- glDrawElementsInstanced(gl_primitive[s->primitive],s->index_array_len, (s->array_len>=(1<<16))?GL_UNSIGNED_INT:GL_UNSIGNED_SHORT,0,amount);
-
- storage->info.render_vertices_count+=s->index_array_len * amount;
+ storage->info.render_vertices_count += s->index_array_len * amount;
} else {
- glDrawArraysInstanced(gl_primitive[s->primitive],0,s->array_len,amount);
-
- storage->info.render_vertices_count+=s->array_len * amount;
+ glDrawArraysInstanced(gl_primitive[s->primitive], 0, s->array_len, amount);
+ storage->info.render_vertices_count += s->array_len * amount;
}
} break;
case VS::INSTANCE_IMMEDIATE: {
- bool restore_tex=false;
- const RasterizerStorageGLES3::Immediate *im = static_cast<const RasterizerStorageGLES3::Immediate*>( e->geometry );
+ bool restore_tex = false;
+ const RasterizerStorageGLES3::Immediate *im = static_cast<const RasterizerStorageGLES3::Immediate *>(e->geometry);
if (im->building) {
return;
@@ -1444,42 +1351,38 @@ void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
glBindBuffer(GL_ARRAY_BUFFER, state.immediate_buffer);
glBindVertexArray(state.immediate_array);
+ for (const List<RasterizerStorageGLES3::Immediate::Chunk>::Element *E = im->chunks.front(); E; E = E->next()) {
- for(const List< RasterizerStorageGLES3::Immediate::Chunk>::Element *E=im->chunks.front();E;E=E->next()) {
-
- const RasterizerStorageGLES3::Immediate::Chunk &c=E->get();
+ const RasterizerStorageGLES3::Immediate::Chunk &c = E->get();
if (c.vertices.empty()) {
continue;
}
int vertices = c.vertices.size();
- uint32_t buf_ofs=0;
+ uint32_t buf_ofs = 0;
- storage->info.render_vertices_count+=vertices;
+ storage->info.render_vertices_count += vertices;
if (c.texture.is_valid() && storage->texture_owner.owns(c.texture)) {
const RasterizerStorageGLES3::Texture *t = storage->texture_owner.get(c.texture);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(t->target,t->tex_id);
- restore_tex=true;
-
+ glBindTexture(t->target, t->tex_id);
+ restore_tex = true;
} else if (restore_tex) {
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,state.current_main_tex);
- restore_tex=false;
+ glBindTexture(GL_TEXTURE_2D, state.current_main_tex);
+ restore_tex = false;
}
-
-
if (!c.normals.empty()) {
glEnableVertexAttribArray(VS::ARRAY_NORMAL);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*vertices,c.normals.ptr());
- glVertexAttribPointer(VS::ARRAY_NORMAL, 3, GL_FLOAT, false,sizeof(Vector3)*vertices,((uint8_t*)NULL)+buf_ofs);
- buf_ofs+=sizeof(Vector3)*vertices;
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector3) * vertices, c.normals.ptr());
+ glVertexAttribPointer(VS::ARRAY_NORMAL, 3, GL_FLOAT, false, sizeof(Vector3) * vertices, ((uint8_t *)NULL) + buf_ofs);
+ buf_ofs += sizeof(Vector3) * vertices;
} else {
@@ -1489,9 +1392,9 @@ void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
if (!c.tangents.empty()) {
glEnableVertexAttribArray(VS::ARRAY_TANGENT);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Plane)*vertices,c.tangents.ptr());
- glVertexAttribPointer(VS::ARRAY_TANGENT, 4, GL_FLOAT, false,sizeof(Plane)*vertices,((uint8_t*)NULL)+buf_ofs);
- buf_ofs+=sizeof(Plane)*vertices;
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Plane) * vertices, c.tangents.ptr());
+ glVertexAttribPointer(VS::ARRAY_TANGENT, 4, GL_FLOAT, false, sizeof(Plane) * vertices, ((uint8_t *)NULL) + buf_ofs);
+ buf_ofs += sizeof(Plane) * vertices;
} else {
@@ -1501,23 +1404,22 @@ void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
if (!c.colors.empty()) {
glEnableVertexAttribArray(VS::ARRAY_COLOR);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Color)*vertices,c.colors.ptr());
- glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, false,sizeof(Color),((uint8_t*)NULL)+buf_ofs);
- buf_ofs+=sizeof(Color)*vertices;
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Color) * vertices, c.colors.ptr());
+ glVertexAttribPointer(VS::ARRAY_COLOR, 4, GL_FLOAT, false, sizeof(Color), ((uint8_t *)NULL) + buf_ofs);
+ buf_ofs += sizeof(Color) * vertices;
} else {
glDisableVertexAttribArray(VS::ARRAY_COLOR);
- glVertexAttrib4f(VS::ARRAY_COLOR,1,1,1,1);
+ glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
}
-
if (!c.uvs.empty()) {
glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector2)*vertices,c.uvs.ptr());
- glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, false,sizeof(Vector2),((uint8_t*)NULL)+buf_ofs);
- buf_ofs+=sizeof(Vector2)*vertices;
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector2) * vertices, c.uvs.ptr());
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, false, sizeof(Vector2), ((uint8_t *)NULL) + buf_ofs);
+ buf_ofs += sizeof(Vector2) * vertices;
} else {
@@ -1527,161 +1429,151 @@ void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
if (!c.uvs2.empty()) {
glEnableVertexAttribArray(VS::ARRAY_TEX_UV2);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector2)*vertices,c.uvs2.ptr());
- glVertexAttribPointer(VS::ARRAY_TEX_UV2, 2, GL_FLOAT, false,sizeof(Vector2),((uint8_t*)NULL)+buf_ofs);
- buf_ofs+=sizeof(Vector2)*vertices;
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector2) * vertices, c.uvs2.ptr());
+ glVertexAttribPointer(VS::ARRAY_TEX_UV2, 2, GL_FLOAT, false, sizeof(Vector2), ((uint8_t *)NULL) + buf_ofs);
+ buf_ofs += sizeof(Vector2) * vertices;
} else {
glDisableVertexAttribArray(VS::ARRAY_TEX_UV2);
}
-
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*vertices,c.vertices.ptr());
- glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false,sizeof(Vector3),((uint8_t*)NULL)+buf_ofs);
- glDrawArrays(gl_primitive[c.primitive],0,c.vertices.size());
-
-
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector3) * vertices, c.vertices.ptr());
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false, sizeof(Vector3), ((uint8_t *)NULL) + buf_ofs);
+ glDrawArrays(gl_primitive[c.primitive], 0, c.vertices.size());
}
-
if (restore_tex) {
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,state.current_main_tex);
- restore_tex=false;
+ glBindTexture(GL_TEXTURE_2D, state.current_main_tex);
+ restore_tex = false;
}
} break;
-
}
-
}
-void RasterizerSceneGLES3::_setup_light(RenderList::Element *e,const Transform& p_view_transform) {
+void RasterizerSceneGLES3::_setup_light(RenderList::Element *e, const Transform &p_view_transform) {
int omni_indices[16];
- int omni_count=0;
+ int omni_count = 0;
int spot_indices[16];
- int spot_count=0;
+ int spot_count = 0;
int reflection_indices[16];
- int reflection_count=0;
+ int reflection_count = 0;
- int maxobj = MIN(16,state.max_forward_lights_per_object);
+ int maxobj = MIN(16, state.max_forward_lights_per_object);
- int lc = e->instance->light_instances.size();
+ int lc = e->instance->light_instances.size();
if (lc) {
- const RID* lights=e->instance->light_instances.ptr();
+ const RID *lights = e->instance->light_instances.ptr();
- for(int i=0;i<lc;i++) {
- LightInstance *li=light_instance_owner.getptr(lights[i]);
- if (li->last_pass!=render_pass) //not visible
+ for (int i = 0; i < lc; i++) {
+ LightInstance *li = light_instance_owner.getptr(lights[i]);
+ if (li->last_pass != render_pass) //not visible
continue;
- if (li->light_ptr->type==VS::LIGHT_OMNI) {
- if (omni_count<maxobj && e->instance->layer_mask&li->light_ptr->cull_mask) {
- omni_indices[omni_count++]=li->light_index;
+ if (li->light_ptr->type == VS::LIGHT_OMNI) {
+ if (omni_count < maxobj && e->instance->layer_mask & li->light_ptr->cull_mask) {
+ omni_indices[omni_count++] = li->light_index;
}
}
- if (li->light_ptr->type==VS::LIGHT_SPOT) {
- if (spot_count<maxobj && e->instance->layer_mask&li->light_ptr->cull_mask) {
- spot_indices[spot_count++]=li->light_index;
+ if (li->light_ptr->type == VS::LIGHT_SPOT) {
+ if (spot_count < maxobj && e->instance->layer_mask & li->light_ptr->cull_mask) {
+ spot_indices[spot_count++] = li->light_index;
}
}
}
}
- state.scene_shader.set_uniform(SceneShaderGLES3::OMNI_LIGHT_COUNT,omni_count);
+ state.scene_shader.set_uniform(SceneShaderGLES3::OMNI_LIGHT_COUNT, omni_count);
if (omni_count) {
- glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::OMNI_LIGHT_INDICES),omni_count,omni_indices);
+ glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::OMNI_LIGHT_INDICES), omni_count, omni_indices);
}
- state.scene_shader.set_uniform(SceneShaderGLES3::SPOT_LIGHT_COUNT,spot_count);
+ state.scene_shader.set_uniform(SceneShaderGLES3::SPOT_LIGHT_COUNT, spot_count);
if (spot_count) {
- glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::SPOT_LIGHT_INDICES),spot_count,spot_indices);
+ glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::SPOT_LIGHT_INDICES), spot_count, spot_indices);
}
-
int rc = e->instance->reflection_probe_instances.size();
-
if (rc) {
+ const RID *reflections = e->instance->reflection_probe_instances.ptr();
- const RID* reflections=e->instance->reflection_probe_instances.ptr();
-
- for(int i=0;i<rc;i++) {
- ReflectionProbeInstance *rpi=reflection_probe_instance_owner.getptr(reflections[i]);
- if (rpi->last_pass!=render_pass) //not visible
+ for (int i = 0; i < rc; i++) {
+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getptr(reflections[i]);
+ if (rpi->last_pass != render_pass) //not visible
continue;
- if (reflection_count<maxobj) {
- reflection_indices[reflection_count++]=rpi->reflection_index;
+ if (reflection_count < maxobj) {
+ reflection_indices[reflection_count++] = rpi->reflection_index;
}
}
}
- state.scene_shader.set_uniform(SceneShaderGLES3::REFLECTION_COUNT,reflection_count);
+ state.scene_shader.set_uniform(SceneShaderGLES3::REFLECTION_COUNT, reflection_count);
if (reflection_count) {
- glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::REFLECTION_INDICES),reflection_count,reflection_indices);
+ glUniform1iv(state.scene_shader.get_uniform(SceneShaderGLES3::REFLECTION_INDICES), reflection_count, reflection_indices);
}
int gi_probe_count = e->instance->gi_probe_instances.size();
if (gi_probe_count) {
- const RID * ridp = e->instance->gi_probe_instances.ptr();
+ const RID *ridp = e->instance->gi_probe_instances.ptr();
GIProbeInstance *gipi = gi_probe_instance_owner.getptr(ridp[0]);
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-6);
- glBindTexture(GL_TEXTURE_3D,gipi->tex_cache);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 6);
+ 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_BIAS1, gipi->probe?gipi->probe->bias: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_MULTIPLIER1, gipi->probe ? gipi->probe->dynamic_range * gipi->probe->energy : 0.0);
+ state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE_BIAS1, gipi->probe ? gipi->probe->bias : 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) {
+ if (gi_probe_count > 1) {
GIProbeInstance *gipi2 = gi_probe_instance_owner.getptr(ridp[1]);
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-7);
- glBindTexture(GL_TEXTURE_3D,gipi2->tex_cache);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 7);
+ glBindTexture(GL_TEXTURE_3D, gipi2->tex_cache);
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_BIAS2, gipi2->probe?gipi2->probe->bias: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 );
+ 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_BIAS2, gipi2->probe ? gipi2->probe->bias : 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 {
- state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE2_ENABLED, false );
+ state.scene_shader.set_uniform(SceneShaderGLES3::GI_PROBE2_ENABLED, false);
}
}
}
-
-void RasterizerSceneGLES3::_setup_transform(InstanceBase *p_instance,const Transform& p_view_transform,const CameraMatrix& p_projection) {
+void RasterizerSceneGLES3::_setup_transform(InstanceBase *p_instance, const Transform &p_view_transform, const CameraMatrix &p_projection) {
if (p_instance->billboard || p_instance->billboard_y || p_instance->depth_scale) {
- Transform xf=p_instance->transform;
+ Transform xf = p_instance->transform;
if (p_instance->depth_scale) {
if (p_projection.matrix[3][3]) {
//orthogonal matrix, try to do about the same
//with viewport size
//real_t w = Math::abs( 1.0/(2.0*(p_projection.matrix[0][0])) );
- real_t h = Math::abs( 1.0/(2.0*p_projection.matrix[1][1]) );
- float sc = (h*2.0); //consistent with Y-fov
- xf.basis.scale( Vector3(sc,sc,sc));
+ real_t h = Math::abs(1.0 / (2.0 * p_projection.matrix[1][1]));
+ float sc = (h * 2.0); //consistent with Y-fov
+ xf.basis.scale(Vector3(sc, sc, sc));
} else {
//just scale by depth
- real_t sc = Plane(p_view_transform.origin,-p_view_transform.get_basis().get_axis(2)).distance_to(xf.origin);
- xf.basis.scale( Vector3(sc,sc,sc));
+ real_t sc = Plane(p_view_transform.origin, -p_view_transform.get_basis().get_axis(2)).distance_to(xf.origin);
+ xf.basis.scale(Vector3(sc, sc, sc));
}
}
@@ -1701,14 +1593,14 @@ void RasterizerSceneGLES3::_setup_transform(InstanceBase *p_instance,const Trans
if (p_instance->billboard_y && storage->frame.current_rt) {
Vector3 scale = xf.basis.get_scale();
- Vector3 look_at = p_view_transform.get_origin();
+ Vector3 look_at = p_view_transform.get_origin();
look_at.y = 0.0;
Vector3 look_at_norm = look_at.normalized();
if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
- xf.set_look_at(xf.origin,xf.origin + look_at_norm, Vector3(0.0, -1.0, 0.0));
+ xf.set_look_at(xf.origin, xf.origin + look_at_norm, Vector3(0.0, -1.0, 0.0));
} else {
- xf.set_look_at(xf.origin,xf.origin + look_at_norm, Vector3(0.0, 1.0, 0.0));
+ xf.set_look_at(xf.origin, xf.origin + look_at_norm, Vector3(0.0, 1.0, 0.0));
}
xf.basis.scale(scale);
}
@@ -1719,22 +1611,20 @@ void RasterizerSceneGLES3::_setup_transform(InstanceBase *p_instance,const Trans
}
}
-void RasterizerSceneGLES3::_set_cull(bool p_front,bool p_reverse_cull) {
+void RasterizerSceneGLES3::_set_cull(bool p_front, bool p_reverse_cull) {
bool front = p_front;
if (p_reverse_cull)
- front=!front;
+ front = !front;
- if (front!=state.cull_front) {
+ if (front != state.cull_front) {
- glCullFace(front?GL_FRONT:GL_BACK);
- state.cull_front=front;
+ glCullFace(front ? GL_FRONT : GL_BACK);
+ state.cull_front = front;
}
}
-
-
-void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements,int p_element_count,const Transform& p_view_transform,const CameraMatrix& p_projection,GLuint p_base_env,bool p_reverse_cull,bool p_alpha_pass,bool p_shadow,bool p_directional_add,bool p_directional_shadows) {
+void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements, int p_element_count, const Transform &p_view_transform, const CameraMatrix &p_projection, GLuint p_base_env, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow, bool p_directional_add, bool p_directional_shadows) {
if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP]) {
//p_reverse_cull=!p_reverse_cull;
@@ -1743,287 +1633,257 @@ void RasterizerSceneGLES3::_render_list(RenderList::Element **p_elements,int p_e
glFrontFace(GL_CW);
}
- glBindBufferBase(GL_UNIFORM_BUFFER,0,state.scene_ubo); //bind globals ubo
-
+ glBindBufferBase(GL_UNIFORM_BUFFER, 0, state.scene_ubo); //bind globals ubo
if (!p_shadow && !p_directional_add) {
- glBindBufferBase(GL_UNIFORM_BUFFER,2,state.env_radiance_ubo); //bind environment radiance info
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-1);
- glBindTexture(GL_TEXTURE_2D,state.brdf_texture);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 2, state.env_radiance_ubo); //bind environment radiance info
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 1);
+ glBindTexture(GL_TEXTURE_2D, state.brdf_texture);
if (p_base_env) {
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-2);
- glBindTexture(GL_TEXTURE_2D,p_base_env);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,true);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 2);
+ glBindTexture(GL_TEXTURE_2D, p_base_env);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP, true);
} else {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
-
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP, false);
}
} else {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP, false);
}
-
- state.cull_front=false;
+ state.cull_front = false;
glCullFace(GL_BACK);
- state.current_depth_test=true;
+ state.current_depth_test = true;
glEnable(GL_DEPTH_TEST);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON, false);
- state.current_blend_mode=-1;
- state.current_line_width=-1;
- state.current_depth_draw=-1;
+ state.current_blend_mode = -1;
+ state.current_line_width = -1;
+ state.current_depth_draw = -1;
- RasterizerStorageGLES3::Material* prev_material=NULL;
- RasterizerStorageGLES3::Geometry* prev_geometry=NULL;
- RasterizerStorageGLES3::GeometryOwner* prev_owner=NULL;
+ RasterizerStorageGLES3::Material *prev_material = NULL;
+ RasterizerStorageGLES3::Geometry *prev_geometry = NULL;
+ RasterizerStorageGLES3::GeometryOwner *prev_owner = NULL;
VS::InstanceType prev_base_type = VS::INSTANCE_MAX;
- int current_blend_mode=-1;
+ int current_blend_mode = -1;
- int prev_shading=-1;
+ int prev_shading = -1;
RID prev_skeleton;
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true); //by default unshaded (easier to set)
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS, true); //by default unshaded (easier to set)
- bool first=true;
+ bool first = true;
- storage->info.render_object_count+=p_element_count;
+ storage->info.render_object_count += p_element_count;
- for (int i=0;i<p_element_count;i++) {
+ for (int i = 0; i < p_element_count; i++) {
RenderList::Element *e = p_elements[i];
- RasterizerStorageGLES3::Material* material= e->material;
+ RasterizerStorageGLES3::Material *material = e->material;
RID skeleton = e->instance->skeleton;
+ bool rebind = first;
- bool rebind=first;
-
- int shading = (e->sort_key>>RenderList::SORT_KEY_SHADING_SHIFT)&RenderList::SORT_KEY_SHADING_MASK;
+ int shading = (e->sort_key >> RenderList::SORT_KEY_SHADING_SHIFT) & RenderList::SORT_KEY_SHADING_MASK;
if (!p_shadow) {
-
-
if (p_directional_add) {
- if (e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG || !(e->instance->layer_mask&directional_light->light_ptr->cull_mask)) {
+ if (e->sort_key & RenderList::SORT_KEY_UNSHADED_FLAG || !(e->instance->layer_mask & directional_light->light_ptr->cull_mask)) {
continue;
}
- shading&=~1; //ignore the ignore directional for base pass
+ shading &= ~1; //ignore the ignore directional for base pass
}
- if (shading!=prev_shading) {
-
- if (e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG) {
-
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,false);
+ if (shading != prev_shading) {
+ if (e->sort_key & RenderList::SORT_KEY_UNSHADED_FLAG) {
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS, true);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES, false);
//state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,true);
} else {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,e->instance->gi_probe_instances.size()>0);
-
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,!p_directional_add);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,shadow_filter_mode==SHADOW_FILTER_PCF5);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,shadow_filter_mode==SHADOW_FILTER_PCF13);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES, e->instance->gi_probe_instances.size() > 0);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING, !p_directional_add);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5, shadow_filter_mode == SHADOW_FILTER_PCF5);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13, shadow_filter_mode == SHADOW_FILTER_PCF13);
- if (p_directional_add || (directional_light && (e->sort_key&RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG)==0)) {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,true);
+ if (p_directional_add || (directional_light && (e->sort_key & RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG) == 0)) {
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL, true);
if (p_directional_shadows && directional_light->light_ptr->shadow) {
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,true);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW, true);
- switch(directional_light->light_ptr->directional_shadow_mode) {
- case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: break; //none
+ switch (directional_light->light_ptr->directional_shadow_mode) {
+ case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL:
+ break; //none
case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS:
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,true);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,directional_light->light_ptr->directional_blend_splits);
- break;
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2, true);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, directional_light->light_ptr->directional_blend_splits);
+ break;
case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS:
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,true);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,directional_light->light_ptr->directional_blend_splits);
- break;
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4, true);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, directional_light->light_ptr->directional_blend_splits);
+ break;
}
}
-
}
-
}
-
-
- rebind=true;
+ rebind = true;
}
-
if (p_alpha_pass || p_directional_add) {
int desired_blend_mode;
if (p_directional_add) {
- desired_blend_mode=RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD;
+ desired_blend_mode = RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD;
} else {
- desired_blend_mode=material->shader->spatial.blend_mode;
+ desired_blend_mode = material->shader->spatial.blend_mode;
}
- if (desired_blend_mode!=current_blend_mode) {
-
+ if (desired_blend_mode != current_blend_mode) {
- switch(desired_blend_mode) {
+ switch (desired_blend_mode) {
- case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX: {
+ case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX: {
glBlendEquation(GL_FUNC_ADD);
if (storage->frame.current_rt && 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 {
+ } else {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
- } break;
- case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD: {
+ } break;
+ case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_ADD: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(p_alpha_pass?GL_SRC_ALPHA:GL_ONE,GL_ONE);
+ glBlendFunc(p_alpha_pass ? GL_SRC_ALPHA : GL_ONE, GL_ONE);
- } break;
- case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_SUB: {
+ } break;
+ case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_SUB: {
glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
- } break;
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+ } break;
case RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MUL: {
glBlendEquation(GL_FUNC_ADD);
if (storage->frame.current_rt && 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 {
+ } else {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
} break;
-
}
- current_blend_mode=desired_blend_mode;
+ current_blend_mode = desired_blend_mode;
}
-
}
-
-
}
- if (prev_skeleton!=skeleton) {
+ if (prev_skeleton != skeleton) {
if (prev_skeleton.is_valid() != skeleton.is_valid()) {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,skeleton.is_valid());
- rebind=true;
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON, skeleton.is_valid());
+ rebind = true;
}
if (skeleton.is_valid()) {
RasterizerStorageGLES3::Skeleton *sk = storage->skeleton_owner.getornull(skeleton);
if (sk->size) {
- glBindBufferBase(GL_UNIFORM_BUFFER,7,sk->ubo);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 7, sk->ubo);
}
}
}
- if ((prev_base_type==VS::INSTANCE_MULTIMESH) != (e->instance->base_type==VS::INSTANCE_MULTIMESH)) {
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING,e->instance->base_type==VS::INSTANCE_MULTIMESH);
- rebind=true;
+ if ((prev_base_type == VS::INSTANCE_MULTIMESH) != (e->instance->base_type == VS::INSTANCE_MULTIMESH)) {
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING, e->instance->base_type == VS::INSTANCE_MULTIMESH);
+ rebind = true;
}
- if (material!=prev_material || rebind) {
+ if (material != prev_material || rebind) {
storage->info.render_material_switch_count++;
- rebind = _setup_material(material,p_alpha_pass);
+ rebind = _setup_material(material, p_alpha_pass);
if (rebind) {
storage->info.render_shader_rebind_count++;
}
}
- if (!(e->sort_key&RenderList::SORT_KEY_UNSHADED_FLAG) && !p_directional_add && !p_shadow) {
- _setup_light(e,p_view_transform);
-
+ if (!(e->sort_key & RenderList::SORT_KEY_UNSHADED_FLAG) && !p_directional_add && !p_shadow) {
+ _setup_light(e, p_view_transform);
}
-
- if (e->owner != prev_owner || prev_base_type != e->instance->base_type || prev_geometry!=e->geometry) {
-
+ if (e->owner != prev_owner || prev_base_type != e->instance->base_type || prev_geometry != e->geometry) {
_setup_geometry(e);
storage->info.render_surface_switch_count++;
-
}
- _set_cull(e->sort_key&RenderList::SORT_KEY_MIRROR_FLAG,p_reverse_cull);
+ _set_cull(e->sort_key & RenderList::SORT_KEY_MIRROR_FLAG, p_reverse_cull);
- state.scene_shader.set_uniform(SceneShaderGLES3::NORMAL_MULT, e->instance->mirror?-1.0:1.0);
+ state.scene_shader.set_uniform(SceneShaderGLES3::NORMAL_MULT, e->instance->mirror ? -1.0 : 1.0);
- _setup_transform(e->instance,p_view_transform,p_projection);
+ _setup_transform(e->instance, p_view_transform, p_projection);
_render_geometry(e);
- prev_material=material;
- prev_base_type=e->instance->base_type;
- prev_geometry=e->geometry;
- prev_owner=e->owner;
- prev_shading=shading;
- prev_skeleton=skeleton;
- first=false;
-
+ prev_material = material;
+ prev_base_type = e->instance->base_type;
+ prev_geometry = e->geometry;
+ prev_owner = e->owner;
+ prev_shading = shading;
+ prev_skeleton = skeleton;
+ first = false;
}
-
-
glFrontFace(GL_CW);
glBindVertexArray(0);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES,false);
-
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_INSTANCING, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_SKELETON, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_RADIANCE_MAP, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_FORWARD_LIGHTING, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_LIGHT_DIRECTIONAL, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_DIRECTIONAL_SHADOW, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM4, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM2, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::LIGHT_USE_PSSM_BLEND, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADELESS, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_5, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::SHADOW_MODE_PCF_13, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_GI_PROBES, false);
}
+void RasterizerSceneGLES3::_add_geometry(RasterizerStorageGLES3::Geometry *p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner, int p_material, bool p_shadow) {
-void RasterizerSceneGLES3::_add_geometry( RasterizerStorageGLES3::Geometry* p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material,bool p_shadow) {
-
- 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);
+ 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;
@@ -2033,42 +1893,40 @@ void RasterizerSceneGLES3::_add_geometry( RasterizerStorageGLES3::Geometry* p_g
*/
if (m_src.is_valid()) {
- m=storage->material_owner.getornull( m_src );
+ m = storage->material_owner.getornull(m_src);
if (!m->shader) {
- m=NULL;
+ m = NULL;
}
}
if (!m) {
- m=storage->material_owner.getptr( default_material );
+ m = storage->material_owner.getptr(default_material);
}
ERR_FAIL_COND(!m);
-
-
- bool has_base_alpha=(m->shader->spatial.uses_alpha);
- bool has_blend_alpha=m->shader->spatial.blend_mode!=RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX || m->shader->spatial.ontop;
+ bool has_base_alpha = (m->shader->spatial.uses_alpha);
+ bool has_blend_alpha = m->shader->spatial.blend_mode != RasterizerStorageGLES3::Shader::Spatial::BLEND_MODE_MIX || m->shader->spatial.ontop;
bool has_alpha = has_base_alpha || has_blend_alpha;
bool shadow = false;
bool mirror = p_instance->mirror;
- if (m->shader->spatial.cull_mode==RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_FRONT) {
- mirror=!mirror;
+ if (m->shader->spatial.cull_mode == RasterizerStorageGLES3::Shader::Spatial::CULL_MODE_FRONT) {
+ mirror = !mirror;
}
if (m->shader->spatial.uses_sss) {
- state.used_sss=true;
+ state.used_sss = true;
}
if (p_shadow) {
- if (has_blend_alpha || (has_base_alpha && m->shader->spatial.depth_draw_mode!=RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
+ if (has_blend_alpha || (has_base_alpha && m->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
return; //bye
- if (!m->shader->spatial.uses_vertex && !m->shader->spatial.uses_discard && m->shader->spatial.depth_draw_mode!=RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+ if (!m->shader->spatial.uses_vertex && !m->shader->spatial.uses_discard && m->shader->spatial.depth_draw_mode != RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
//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 = storage->material_owner.getptr(default_material_twosided);
@@ -2076,47 +1934,43 @@ void RasterizerSceneGLES3::_add_geometry( RasterizerStorageGLES3::Geometry* p_g
m = storage->material_owner.getptr(default_material);
}
- has_alpha=false;
-
+ has_alpha = false;
}
-
-
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->sort_key=0;
+ e->geometry = p_geometry;
+ e->material = m;
+ e->instance = p_instance;
+ e->owner = p_owner;
+ e->sort_key = 0;
- if (e->geometry->last_pass!=render_pass) {
- e->geometry->last_pass=render_pass;
- e->geometry->index=current_geometry_index++;
+ if (e->geometry->last_pass != render_pass) {
+ e->geometry->last_pass = render_pass;
+ e->geometry->index = current_geometry_index++;
}
- if (!p_shadow && directional_light && (directional_light->light_ptr->cull_mask&e->instance->layer_mask)==0) {
- e->sort_key|=RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG;
+ if (!p_shadow && directional_light && (directional_light->light_ptr->cull_mask & e->instance->layer_mask) == 0) {
+ e->sort_key |= RenderList::SORT_KEY_NO_DIRECTIONAL_FLAG;
}
- e->sort_key|=uint64_t(e->geometry->index)<<RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
- e->sort_key|=uint64_t(e->instance->base_type)<<RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
+ e->sort_key |= uint64_t(e->geometry->index) << RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
+ e->sort_key |= uint64_t(e->instance->base_type) << RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
if (!p_shadow) {
-
- if (e->material->last_pass!=render_pass) {
- e->material->last_pass=render_pass;
- e->material->index=current_material_index++;
+ 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;
+ 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 (!has_blend_alpha && has_alpha && m->shader->spatial.depth_draw_mode==RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+ if (!has_blend_alpha && has_alpha && m->shader->spatial.depth_draw_mode == RasterizerStorageGLES3::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
//if nothing exists, add this element as opaque too
RenderList::Element *oe = render_list.add_element();
@@ -2124,11 +1978,11 @@ void RasterizerSceneGLES3::_add_geometry( RasterizerStorageGLES3::Geometry* p_g
if (!oe)
return;
- copymem(oe,e,sizeof(RenderList::Element));
+ copymem(oe, e, sizeof(RenderList::Element));
}
if (e->instance->gi_probe_instances.size()) {
- e->sort_key|=RenderList::SORT_KEY_GI_PROBES_FLAG;
+ e->sort_key |= RenderList::SORT_KEY_GI_PROBES_FLAG;
}
}
@@ -2137,20 +1991,19 @@ void RasterizerSceneGLES3::_add_geometry( RasterizerStorageGLES3::Geometry* p_g
e->sort_flags|=RenderList::SORT_FLAG_INSTANCING;
*/
-
if (mirror) {
- e->sort_key|=RenderList::SORT_KEY_MIRROR_FLAG;
+ e->sort_key |= RenderList::SORT_KEY_MIRROR_FLAG;
}
//e->light_type=0xFF; // no lights!
if (shadow || m->shader->spatial.unshaded /*|| current_debug==VS::SCENARIO_DEBUG_SHADELESS*/) {
- e->sort_key|=RenderList::SORT_KEY_UNSHADED_FLAG;
+ e->sort_key |= RenderList::SORT_KEY_UNSHADED_FLAG;
}
}
-void RasterizerSceneGLES3::_draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox,const CameraMatrix& p_projection,const Transform& p_transform,bool p_vflip,float p_scale) {
+void RasterizerSceneGLES3::_draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox, const CameraMatrix &p_projection, const Transform &p_transform, bool p_vflip, float p_scale) {
if (!p_skybox)
return;
@@ -2159,16 +2012,15 @@ void RasterizerSceneGLES3::_draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox
ERR_FAIL_COND(!tex);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(tex->target,tex->tex_id);
-
+ glBindTexture(tex->target, tex->tex_id);
if (storage->config.srgb_decode_supported && tex->srgb && !tex->using_srgb) {
- glTexParameteri(tex->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
- tex->using_srgb=true;
+ glTexParameteri(tex->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
+ tex->using_srgb = true;
#ifdef TOOLS_ENABLED
- if (!(tex->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
- tex->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+ if (!(tex->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+ tex->flags |= VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
//notify that texture must be set to linear beforehand, so it works in other platforms when exported
}
#endif
@@ -2179,400 +2031,366 @@ void RasterizerSceneGLES3::_draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDepthFunc(GL_LEQUAL);
- glColorMask(1,1,1,1);
+ glColorMask(1, 1, 1, 1);
- float flip_sign = p_vflip?-1:1;
+ float flip_sign = p_vflip ? -1 : 1;
- Vector3 vertices[8]={
- Vector3(-1,-1*flip_sign,1),
- Vector3( 0, 1, 0),
- Vector3( 1,-1*flip_sign,1),
- Vector3( 1, 1, 0),
- Vector3( 1, 1*flip_sign,1),
- Vector3( 1, 0, 0),
- Vector3(-1, 1*flip_sign,1),
- Vector3( 0, 0, 0)
+ Vector3 vertices[8] = {
+ Vector3(-1, -1 * flip_sign, 1),
+ Vector3(0, 1, 0),
+ Vector3(1, -1 * flip_sign, 1),
+ Vector3(1, 1, 0),
+ Vector3(1, 1 * flip_sign, 1),
+ Vector3(1, 0, 0),
+ Vector3(-1, 1 * flip_sign, 1),
+ Vector3(0, 0, 0)
};
-
-
//skybox uv vectors
- float vw,vh,zn;
- p_projection.get_viewport_size(vw,vh);
- zn=p_projection.get_z_near();
+ float vw, vh, zn;
+ p_projection.get_viewport_size(vw, vh);
+ zn = p_projection.get_z_near();
- float scale=p_scale;
+ float scale = p_scale;
- for(int i=0;i<4;i++) {
+ for (int i = 0; i < 4; i++) {
- Vector3 uv=vertices[i*2+1];
- uv.x=(uv.x*2.0-1.0)*vw*scale;
- uv.y=-(uv.y*2.0-1.0)*vh*scale;
- uv.z=-zn;
- vertices[i*2+1] = p_transform.basis.xform(uv).normalized();
- vertices[i*2+1].z = -vertices[i*2+1].z;
+ Vector3 uv = vertices[i * 2 + 1];
+ uv.x = (uv.x * 2.0 - 1.0) * vw * scale;
+ uv.y = -(uv.y * 2.0 - 1.0) * vh * scale;
+ uv.z = -zn;
+ vertices[i * 2 + 1] = p_transform.basis.xform(uv).normalized();
+ vertices[i * 2 + 1].z = -vertices[i * 2 + 1].z;
}
- glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
- glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(Vector3)*8,vertices);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, state.skybox_verts);
+ glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vector3) * 8, vertices);
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
glBindVertexArray(state.skybox_array);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP,true);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP, true);
storage->shaders.copy.bind();
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
- glColorMask(1,1,1,1);
-
- storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP,false);
+ glColorMask(1, 1, 1, 1);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::USE_CUBEMAP, false);
}
-
-void RasterizerSceneGLES3::_setup_environment(Environment *env,const CameraMatrix& p_cam_projection,const Transform& p_cam_transform) {
-
+void RasterizerSceneGLES3::_setup_environment(Environment *env, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform) {
//store camera into 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);
+ 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);
//time global variables
- for(int i=0;i<4;i++) {
- state.ubo_data.time[i]=storage->frame.time[i];
+ for (int i = 0; i < 4; i++) {
+ state.ubo_data.time[i] = storage->frame.time[i];
}
//bg and ambient
if (env) {
- state.ubo_data.bg_energy=env->bg_energy;
- state.ubo_data.ambient_energy=env->ambient_energy;
+ state.ubo_data.bg_energy = env->bg_energy;
+ state.ubo_data.ambient_energy = env->ambient_energy;
Color linear_ambient_color = env->ambient_color.to_linear();
- state.ubo_data.ambient_light_color[0]=linear_ambient_color.r;
- state.ubo_data.ambient_light_color[1]=linear_ambient_color.g;
- state.ubo_data.ambient_light_color[2]=linear_ambient_color.b;
- state.ubo_data.ambient_light_color[3]=linear_ambient_color.a;
+ state.ubo_data.ambient_light_color[0] = linear_ambient_color.r;
+ state.ubo_data.ambient_light_color[1] = linear_ambient_color.g;
+ state.ubo_data.ambient_light_color[2] = linear_ambient_color.b;
+ state.ubo_data.ambient_light_color[3] = linear_ambient_color.a;
Color bg_color;
- switch(env->bg_mode) {
+ switch (env->bg_mode) {
case VS::ENV_BG_CLEAR_COLOR: {
- bg_color=storage->frame.clear_request_color.to_linear();
+ bg_color = storage->frame.clear_request_color.to_linear();
} break;
case VS::ENV_BG_COLOR: {
- bg_color=env->bg_color.to_linear();
+ bg_color = env->bg_color.to_linear();
} break;
default: {
- bg_color=Color(0,0,0,1);
+ bg_color = Color(0, 0, 0, 1);
} break;
}
- state.ubo_data.bg_color[0]=bg_color.r;
- state.ubo_data.bg_color[1]=bg_color.g;
- state.ubo_data.bg_color[2]=bg_color.b;
- state.ubo_data.bg_color[3]=bg_color.a;
+ state.ubo_data.bg_color[0] = bg_color.r;
+ state.ubo_data.bg_color[1] = bg_color.g;
+ state.ubo_data.bg_color[2] = bg_color.b;
+ state.ubo_data.bg_color[3] = bg_color.a;
- state.env_radiance_data.ambient_contribution=env->ambient_skybox_contribution;
- state.ubo_data.ambient_occlusion_affect_light=env->ssao_light_affect;
+ state.env_radiance_data.ambient_contribution = env->ambient_skybox_contribution;
+ state.ubo_data.ambient_occlusion_affect_light = env->ssao_light_affect;
} else {
- state.ubo_data.bg_energy=1.0;
- state.ubo_data.ambient_energy=1.0;
+ state.ubo_data.bg_energy = 1.0;
+ state.ubo_data.ambient_energy = 1.0;
//use from clear color instead, since there is no ambient
Color linear_ambient_color = storage->frame.clear_request_color.to_linear();
- state.ubo_data.ambient_light_color[0]=linear_ambient_color.r;
- state.ubo_data.ambient_light_color[1]=linear_ambient_color.g;
- state.ubo_data.ambient_light_color[2]=linear_ambient_color.b;
- state.ubo_data.ambient_light_color[3]=linear_ambient_color.a;
-
- state.ubo_data.bg_color[0]=linear_ambient_color.r;
- state.ubo_data.bg_color[1]=linear_ambient_color.g;
- state.ubo_data.bg_color[2]=linear_ambient_color.b;
- state.ubo_data.bg_color[3]=linear_ambient_color.a;
+ state.ubo_data.ambient_light_color[0] = linear_ambient_color.r;
+ state.ubo_data.ambient_light_color[1] = linear_ambient_color.g;
+ state.ubo_data.ambient_light_color[2] = linear_ambient_color.b;
+ state.ubo_data.ambient_light_color[3] = linear_ambient_color.a;
- state.env_radiance_data.ambient_contribution=0;
- state.ubo_data.ambient_occlusion_affect_light=0;
+ state.ubo_data.bg_color[0] = linear_ambient_color.r;
+ state.ubo_data.bg_color[1] = linear_ambient_color.g;
+ state.ubo_data.bg_color[2] = linear_ambient_color.b;
+ state.ubo_data.bg_color[3] = linear_ambient_color.a;
+ state.env_radiance_data.ambient_contribution = 0;
+ state.ubo_data.ambient_occlusion_affect_light = 0;
}
{
//directional shadow
- state.ubo_data.shadow_directional_pixel_size[0]=1.0/directional_shadow.size;
- state.ubo_data.shadow_directional_pixel_size[1]=1.0/directional_shadow.size;
+ state.ubo_data.shadow_directional_pixel_size[0] = 1.0 / directional_shadow.size;
+ state.ubo_data.shadow_directional_pixel_size[1] = 1.0 / directional_shadow.size;
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-4);
- glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 4);
+ glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
}
-
-
glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(State::SceneDataUBO), &state.ubo_data);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(State::SceneDataUBO), &state.ubo_data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
//fill up environment
- store_transform(p_cam_transform,state.env_radiance_data.transform);
-
+ store_transform(p_cam_transform, state.env_radiance_data.transform);
glBindBuffer(GL_UNIFORM_BUFFER, state.env_radiance_ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0,sizeof(State::EnvironmentRadianceUBO), &state.env_radiance_data);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(State::EnvironmentRadianceUBO), &state.env_radiance_data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
}
-void RasterizerSceneGLES3::_setup_directional_light(int p_index,const Transform& p_camera_inverse_transform,bool p_use_shadows) {
+void RasterizerSceneGLES3::_setup_directional_light(int p_index, const Transform &p_camera_inverse_transform, bool p_use_shadows) {
LightInstance *li = directional_lights[p_index];
LightDataUBO ubo_data; //used for filling
- float sign = li->light_ptr->negative?-1:1;
+ float sign = li->light_ptr->negative ? -1 : 1;
Color linear_col = li->light_ptr->color.to_linear();
- ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[3]=0;
+ ubo_data.light_color_energy[0] = linear_col.r * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[1] = linear_col.g * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[2] = linear_col.b * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[3] = 0;
//omni, keep at 0
- ubo_data.light_pos_inv_radius[0]=0.0;
- ubo_data.light_pos_inv_radius[1]=0.0;
- ubo_data.light_pos_inv_radius[2]=0.0;
- ubo_data.light_pos_inv_radius[3]=0.0;
+ ubo_data.light_pos_inv_radius[0] = 0.0;
+ ubo_data.light_pos_inv_radius[1] = 0.0;
+ ubo_data.light_pos_inv_radius[2] = 0.0;
+ ubo_data.light_pos_inv_radius[3] = 0.0;
- Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0,0,-1))).normalized();
- ubo_data.light_direction_attenuation[0]=direction.x;
- ubo_data.light_direction_attenuation[1]=direction.y;
- ubo_data.light_direction_attenuation[2]=direction.z;
- ubo_data.light_direction_attenuation[3]=1.0;
+ Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0, 0, -1))).normalized();
+ ubo_data.light_direction_attenuation[0] = direction.x;
+ ubo_data.light_direction_attenuation[1] = direction.y;
+ ubo_data.light_direction_attenuation[2] = direction.z;
+ ubo_data.light_direction_attenuation[3] = 1.0;
- ubo_data.light_params[0]=0;
- ubo_data.light_params[1]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
- ubo_data.light_params[2]=0;
- ubo_data.light_params[3]=0;
+ ubo_data.light_params[0] = 0;
+ ubo_data.light_params[1] = li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+ ubo_data.light_params[2] = 0;
+ ubo_data.light_params[3] = 0;
Color shadow_color = li->light_ptr->shadow_color.to_linear();
- ubo_data.light_shadow_color_contact[0]=shadow_color.r;
- ubo_data.light_shadow_color_contact[1]=shadow_color.g;
- ubo_data.light_shadow_color_contact[2]=shadow_color.b;
- ubo_data.light_shadow_color_contact[3]=li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
-
+ ubo_data.light_shadow_color_contact[0] = shadow_color.r;
+ ubo_data.light_shadow_color_contact[1] = shadow_color.g;
+ ubo_data.light_shadow_color_contact[2] = shadow_color.b;
+ ubo_data.light_shadow_color_contact[3] = li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
if (p_use_shadows && li->light_ptr->shadow) {
- int shadow_count=0;
+ int shadow_count = 0;
- switch(li->light_ptr->directional_shadow_mode) {
+ switch (li->light_ptr->directional_shadow_mode) {
case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
- shadow_count=1;
+ shadow_count = 1;
} break;
case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
- shadow_count=2;
+ shadow_count = 2;
} break;
case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
- shadow_count=4;
+ shadow_count = 4;
} break;
-
}
- for(int j=0;j<shadow_count;j++) {
-
+ for (int j = 0; j < shadow_count; j++) {
- uint32_t x=li->directional_rect.pos.x;
- uint32_t y=li->directional_rect.pos.y;
- uint32_t width=li->directional_rect.size.x;
- uint32_t height=li->directional_rect.size.y;
+ uint32_t x = li->directional_rect.pos.x;
+ uint32_t y = li->directional_rect.pos.y;
+ uint32_t width = li->directional_rect.size.x;
+ uint32_t height = li->directional_rect.size.y;
+ if (li->light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+ width /= 2;
+ height /= 2;
- if (li->light_ptr->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
-
-
- width/=2;
- height/=2;
-
- if (j==0) {
-
- } else if (j==1) {
- x+=width;
- } else if (j==2) {
- y+=height;
- } else if (j==3) {
- x+=width;
- y+=height;
+ if (j == 0) {
+ } else if (j == 1) {
+ x += width;
+ } else if (j == 2) {
+ y += height;
+ } else if (j == 3) {
+ x += width;
+ y += height;
}
+ } else if (li->light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+ height /= 2;
- } else if (li->light_ptr->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
-
- height/=2;
-
- if (j==0) {
+ if (j == 0) {
} else {
- y+=height;
+ y += height;
}
-
}
- ubo_data.shadow_split_offsets[j]=1.0/li->shadow_transform[j].split;
+ ubo_data.shadow_split_offsets[j] = 1.0 / li->shadow_transform[j].split;
Transform modelview = (p_camera_inverse_transform * li->shadow_transform[j].transform).inverse();
CameraMatrix bias;
bias.set_light_bias();
CameraMatrix rectm;
- Rect2 atlas_rect = Rect2(float(x)/directional_shadow.size,float(y)/directional_shadow.size,float(width)/directional_shadow.size,float(height)/directional_shadow.size);
+ Rect2 atlas_rect = Rect2(float(x) / directional_shadow.size, float(y) / directional_shadow.size, float(width) / directional_shadow.size, float(height) / directional_shadow.size);
rectm.set_light_atlas_rect(atlas_rect);
-
CameraMatrix shadow_mtx = rectm * bias * li->shadow_transform[j].camera * modelview;
- store_camera(shadow_mtx,&ubo_data.shadow_matrix1[16*j]);
-
- ubo_data.light_clamp[0]=atlas_rect.pos.x;
- ubo_data.light_clamp[1]=atlas_rect.pos.y;
- ubo_data.light_clamp[2]=atlas_rect.size.x;
- ubo_data.light_clamp[3]=atlas_rect.size.y;
+ store_camera(shadow_mtx, &ubo_data.shadow_matrix1[16 * j]);
+ ubo_data.light_clamp[0] = atlas_rect.pos.x;
+ ubo_data.light_clamp[1] = atlas_rect.pos.y;
+ ubo_data.light_clamp[2] = atlas_rect.size.x;
+ ubo_data.light_clamp[3] = atlas_rect.size.y;
}
-
}
glBindBuffer(GL_UNIFORM_BUFFER, state.directional_ubo);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(LightDataUBO), &ubo_data);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
- directional_light=li;
-
- glBindBufferBase(GL_UNIFORM_BUFFER,3,state.directional_ubo);
+ directional_light = li;
+ glBindBufferBase(GL_UNIFORM_BUFFER, 3, state.directional_ubo);
}
-void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result,int p_light_cull_count,const Transform& p_camera_inverse_transform,const CameraMatrix& p_camera_projection,RID p_shadow_atlas) {
-
+void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_shadow_atlas) {
- state.omni_light_count=0;
- state.spot_light_count=0;
- state.directional_light_count=0;
+ state.omni_light_count = 0;
+ state.spot_light_count = 0;
+ state.directional_light_count = 0;
- directional_light=NULL;
+ directional_light = NULL;
ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+ for (int i = 0; i < p_light_cull_count; i++) {
- for(int i=0;i<p_light_cull_count;i++) {
-
- ERR_BREAK( i>=RenderList::MAX_LIGHTS );
+ ERR_BREAK(i >= RenderList::MAX_LIGHTS);
LightInstance *li = light_instance_owner.getptr(p_light_cull_result[i]);
LightDataUBO ubo_data; //used for filling
- switch(li->light_ptr->type) {
+ switch (li->light_ptr->type) {
case VS::LIGHT_DIRECTIONAL: {
- if (state.directional_light_count<RenderList::MAX_DIRECTIONAL_LIGHTS) {
- directional_lights[state.directional_light_count++]=li;
+ if (state.directional_light_count < RenderList::MAX_DIRECTIONAL_LIGHTS) {
+ directional_lights[state.directional_light_count++] = li;
}
-
} break;
case VS::LIGHT_OMNI: {
- float sign = li->light_ptr->negative?-1:1;
+ float sign = li->light_ptr->negative ? -1 : 1;
Color linear_col = li->light_ptr->color.to_linear();
- ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[3]=0;
-
+ ubo_data.light_color_energy[0] = linear_col.r * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[1] = linear_col.g * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[2] = linear_col.b * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[3] = 0;
Vector3 pos = p_camera_inverse_transform.xform(li->transform.origin);
//directional, keep at 0
- ubo_data.light_pos_inv_radius[0]=pos.x;
- ubo_data.light_pos_inv_radius[1]=pos.y;
- ubo_data.light_pos_inv_radius[2]=pos.z;
- ubo_data.light_pos_inv_radius[3]=1.0/MAX(0.001,li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
+ ubo_data.light_pos_inv_radius[0] = pos.x;
+ ubo_data.light_pos_inv_radius[1] = pos.y;
+ ubo_data.light_pos_inv_radius[2] = pos.z;
+ ubo_data.light_pos_inv_radius[3] = 1.0 / MAX(0.001, li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
- ubo_data.light_direction_attenuation[0]=0;
- ubo_data.light_direction_attenuation[1]=0;
- ubo_data.light_direction_attenuation[2]=0;
- ubo_data.light_direction_attenuation[3]=li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+ ubo_data.light_direction_attenuation[0] = 0;
+ ubo_data.light_direction_attenuation[1] = 0;
+ ubo_data.light_direction_attenuation[2] = 0;
+ ubo_data.light_direction_attenuation[3] = li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
- ubo_data.light_params[0]=0;
- ubo_data.light_params[1]=0;
- ubo_data.light_params[2]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
- ubo_data.light_params[3]=0;
+ ubo_data.light_params[0] = 0;
+ ubo_data.light_params[1] = 0;
+ ubo_data.light_params[2] = li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+ ubo_data.light_params[3] = 0;
Color shadow_color = li->light_ptr->shadow_color.to_linear();
- ubo_data.light_shadow_color_contact[0]=shadow_color.r;
- ubo_data.light_shadow_color_contact[1]=shadow_color.g;
- ubo_data.light_shadow_color_contact[2]=shadow_color.b;
- ubo_data.light_shadow_color_contact[3]=li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
+ ubo_data.light_shadow_color_contact[0] = shadow_color.r;
+ ubo_data.light_shadow_color_contact[1] = shadow_color.g;
+ ubo_data.light_shadow_color_contact[2] = shadow_color.b;
+ ubo_data.light_shadow_color_contact[3] = li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
if (li->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(li->self)) {
// fill in the shadow information
uint32_t key = shadow_atlas->shadow_owners[li->self];
- uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
+ uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
- ERR_CONTINUE(shadow>=shadow_atlas->quadrants[quadrant].shadows.size());
+ ERR_CONTINUE(shadow >= shadow_atlas->quadrants[quadrant].shadows.size());
uint32_t atlas_size = shadow_atlas->size;
- uint32_t quadrant_size = atlas_size>>1;
+ uint32_t quadrant_size = atlas_size >> 1;
- uint32_t x=(quadrant&1)*quadrant_size;
- uint32_t y=(quadrant>>1)*quadrant_size;
+ uint32_t x = (quadrant & 1) * quadrant_size;
+ uint32_t y = (quadrant >> 1) * quadrant_size;
uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
- x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+ x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+ y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- uint32_t width=shadow_size;
- uint32_t height=shadow_size;
+ uint32_t width = shadow_size;
+ uint32_t height = shadow_size;
+ if (li->light_ptr->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
- if (li->light_ptr->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
-
- height/=2;
+ height /= 2;
} else {
- width/=2;
-
+ width /= 2;
}
Transform proj = (p_camera_inverse_transform * li->transform).inverse();
- store_transform(proj,ubo_data.shadow_matrix1);
-
- ubo_data.light_params[3]=1.0; //means it has shadow
- ubo_data.light_clamp[0]=float(x)/atlas_size;
- ubo_data.light_clamp[1]=float(y)/atlas_size;
- ubo_data.light_clamp[2]=float(width)/atlas_size;
- ubo_data.light_clamp[3]=float(height)/atlas_size;
+ store_transform(proj, ubo_data.shadow_matrix1);
+ ubo_data.light_params[3] = 1.0; //means it has shadow
+ ubo_data.light_clamp[0] = float(x) / atlas_size;
+ ubo_data.light_clamp[1] = float(y) / atlas_size;
+ ubo_data.light_clamp[2] = float(width) / atlas_size;
+ ubo_data.light_clamp[3] = float(height) / atlas_size;
}
-
- li->light_index=state.omni_light_count;
- copymem(&state.omni_array_tmp[li->light_index*state.ubo_light_size],&ubo_data,state.ubo_light_size);
+ li->light_index = state.omni_light_count;
+ copymem(&state.omni_array_tmp[li->light_index * state.ubo_light_size], &ubo_data, state.ubo_light_size);
state.omni_light_count++;
-
-
#if 0
if (li->light_ptr->shadow_enabled) {
li->shadow_projection[0] = Transform(camera_transform_inverse * li->transform).inverse();
@@ -2582,69 +2400,69 @@ void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result,int p_light_cu
} break;
case VS::LIGHT_SPOT: {
- float sign = li->light_ptr->negative?-1:1;
+ float sign = li->light_ptr->negative ? -1 : 1;
Color linear_col = li->light_ptr->color.to_linear();
- ubo_data.light_color_energy[0]=linear_col.r*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[1]=linear_col.g*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[2]=linear_col.b*sign*li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
- ubo_data.light_color_energy[3]=0;
+ ubo_data.light_color_energy[0] = linear_col.r * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[1] = linear_col.g * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[2] = linear_col.b * sign * li->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+ ubo_data.light_color_energy[3] = 0;
Vector3 pos = p_camera_inverse_transform.xform(li->transform.origin);
//directional, keep at 0
- ubo_data.light_pos_inv_radius[0]=pos.x;
- ubo_data.light_pos_inv_radius[1]=pos.y;
- ubo_data.light_pos_inv_radius[2]=pos.z;
- ubo_data.light_pos_inv_radius[3]=1.0/MAX(0.001,li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
+ ubo_data.light_pos_inv_radius[0] = pos.x;
+ ubo_data.light_pos_inv_radius[1] = pos.y;
+ ubo_data.light_pos_inv_radius[2] = pos.z;
+ ubo_data.light_pos_inv_radius[3] = 1.0 / MAX(0.001, li->light_ptr->param[VS::LIGHT_PARAM_RANGE]);
- Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0,0,-1))).normalized();
- ubo_data.light_direction_attenuation[0]=direction.x;
- ubo_data.light_direction_attenuation[1]=direction.y;
- ubo_data.light_direction_attenuation[2]=direction.z;
- ubo_data.light_direction_attenuation[3]=li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+ Vector3 direction = p_camera_inverse_transform.basis.xform(li->transform.basis.xform(Vector3(0, 0, -1))).normalized();
+ ubo_data.light_direction_attenuation[0] = direction.x;
+ ubo_data.light_direction_attenuation[1] = direction.y;
+ ubo_data.light_direction_attenuation[2] = direction.z;
+ ubo_data.light_direction_attenuation[3] = li->light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
- ubo_data.light_params[0]=li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ATTENUATION];
- ubo_data.light_params[1]=Math::cos(Math::deg2rad(li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ANGLE]));
- ubo_data.light_params[2]=li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
- ubo_data.light_params[3]=0;
+ ubo_data.light_params[0] = li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ATTENUATION];
+ ubo_data.light_params[1] = Math::cos(Math::deg2rad(li->light_ptr->param[VS::LIGHT_PARAM_SPOT_ANGLE]));
+ ubo_data.light_params[2] = li->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+ ubo_data.light_params[3] = 0;
Color shadow_color = li->light_ptr->shadow_color.to_linear();
- ubo_data.light_shadow_color_contact[0]=shadow_color.r;
- ubo_data.light_shadow_color_contact[1]=shadow_color.g;
- ubo_data.light_shadow_color_contact[2]=shadow_color.b;
- ubo_data.light_shadow_color_contact[3]=li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
+ ubo_data.light_shadow_color_contact[0] = shadow_color.r;
+ ubo_data.light_shadow_color_contact[1] = shadow_color.g;
+ ubo_data.light_shadow_color_contact[2] = shadow_color.b;
+ ubo_data.light_shadow_color_contact[3] = li->light_ptr->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE];
if (li->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(li->self)) {
// fill in the shadow information
uint32_t key = shadow_atlas->shadow_owners[li->self];
- uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT)&0x3;
+ uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
- ERR_CONTINUE(shadow>=shadow_atlas->quadrants[quadrant].shadows.size());
+ ERR_CONTINUE(shadow >= shadow_atlas->quadrants[quadrant].shadows.size());
uint32_t atlas_size = shadow_atlas->size;
- uint32_t quadrant_size = atlas_size>>1;
+ uint32_t quadrant_size = atlas_size >> 1;
- uint32_t x=(quadrant&1)*quadrant_size;
- uint32_t y=(quadrant>>1)*quadrant_size;
+ uint32_t x = (quadrant & 1) * quadrant_size;
+ uint32_t y = (quadrant >> 1) * quadrant_size;
uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
- x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+ x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+ y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- uint32_t width=shadow_size;
- uint32_t height=shadow_size;
+ uint32_t width = shadow_size;
+ uint32_t height = shadow_size;
- Rect2 rect(float(x)/atlas_size,float(y)/atlas_size,float(width)/atlas_size,float(height)/atlas_size);
+ Rect2 rect(float(x) / atlas_size, float(y) / atlas_size, float(width) / atlas_size, float(height) / atlas_size);
- ubo_data.light_params[3]=1.0; //means it has shadow
- ubo_data.light_clamp[0]=rect.pos.x;
- ubo_data.light_clamp[1]=rect.pos.y;
- ubo_data.light_clamp[2]=rect.size.x;
- ubo_data.light_clamp[3]=rect.size.y;
+ ubo_data.light_params[3] = 1.0; //means it has shadow
+ ubo_data.light_clamp[0] = rect.pos.x;
+ ubo_data.light_clamp[1] = rect.pos.y;
+ ubo_data.light_clamp[2] = rect.size.x;
+ ubo_data.light_clamp[3] = rect.size.y;
Transform modelview = (p_camera_inverse_transform * li->transform).inverse();
@@ -2655,13 +2473,11 @@ void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result,int p_light_cu
CameraMatrix shadow_mtx = rectm * bias * li->shadow_transform[0].camera * modelview;
- store_camera(shadow_mtx,ubo_data.shadow_matrix1);
-
-
+ store_camera(shadow_mtx, ubo_data.shadow_matrix1);
}
- li->light_index=state.spot_light_count;
- copymem(&state.spot_array_tmp[li->light_index*state.ubo_light_size],&ubo_data,state.ubo_light_size);
+ li->light_index = state.spot_light_count;
+ copymem(&state.spot_array_tmp[li->light_index * state.ubo_light_size], &ubo_data, state.ubo_light_size);
state.spot_light_count++;
#if 0
@@ -2674,225 +2490,200 @@ void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result,int p_light_cu
}
#endif
} break;
-
}
-
- li->last_pass=render_pass;
+ li->last_pass = render_pass;
//update UBO for forward rendering, blit to texture for clustered
-
}
-
-
if (state.omni_light_count) {
glBindBuffer(GL_UNIFORM_BUFFER, state.omni_array_ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0, state.omni_light_count*state.ubo_light_size, state.omni_array_tmp);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, state.omni_light_count * state.ubo_light_size, state.omni_array_tmp);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
- glBindBufferBase(GL_UNIFORM_BUFFER,4,state.omni_array_ubo);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 4, state.omni_array_ubo);
if (state.spot_light_count) {
glBindBuffer(GL_UNIFORM_BUFFER, state.spot_array_ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0, state.spot_light_count*state.ubo_light_size, state.spot_array_tmp);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, state.spot_light_count * state.ubo_light_size, state.spot_array_tmp);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
}
- glBindBufferBase(GL_UNIFORM_BUFFER,5,state.spot_array_ubo);
-
-
+ glBindBufferBase(GL_UNIFORM_BUFFER, 5, state.spot_array_ubo);
}
-void RasterizerSceneGLES3::_setup_reflections(RID *p_reflection_probe_cull_result,int p_reflection_probe_cull_count,const Transform& p_camera_inverse_transform,const CameraMatrix& p_camera_projection,RID p_reflection_atlas,Environment *p_env) {
+void RasterizerSceneGLES3::_setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_reflection_atlas, Environment *p_env) {
- state.reflection_probe_count=0;
+ state.reflection_probe_count = 0;
- for(int i=0;i<p_reflection_probe_cull_count;i++) {
+ for (int i = 0; i < p_reflection_probe_cull_count; i++) {
- ReflectionProbeInstance *rpi=reflection_probe_instance_owner.getornull(p_reflection_probe_cull_result[i]);
+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_reflection_probe_cull_result[i]);
ERR_CONTINUE(!rpi);
- ReflectionAtlas *reflection_atlas=reflection_atlas_owner.getornull(p_reflection_atlas);
+ ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
ERR_CONTINUE(!reflection_atlas);
- ERR_CONTINUE(rpi->reflection_atlas_index<0);
+ ERR_CONTINUE(rpi->reflection_atlas_index < 0);
-
- if (state.reflection_probe_count>=state.max_ubo_reflections)
+ if (state.reflection_probe_count >= state.max_ubo_reflections)
break;
- rpi->last_pass=render_pass;
-
+ rpi->last_pass = render_pass;
ReflectionProbeDataUBO reflection_ubo;
- reflection_ubo.box_extents[0]=rpi->probe_ptr->extents.x;
- reflection_ubo.box_extents[1]=rpi->probe_ptr->extents.y;
- reflection_ubo.box_extents[2]=rpi->probe_ptr->extents.z;
- reflection_ubo.box_extents[3]=0;
-
+ reflection_ubo.box_extents[0] = rpi->probe_ptr->extents.x;
+ reflection_ubo.box_extents[1] = rpi->probe_ptr->extents.y;
+ reflection_ubo.box_extents[2] = rpi->probe_ptr->extents.z;
+ reflection_ubo.box_extents[3] = 0;
+ reflection_ubo.box_ofs[0] = rpi->probe_ptr->origin_offset.x;
+ reflection_ubo.box_ofs[1] = rpi->probe_ptr->origin_offset.y;
+ reflection_ubo.box_ofs[2] = rpi->probe_ptr->origin_offset.z;
+ reflection_ubo.box_ofs[3] = 0;
- reflection_ubo.box_ofs[0]=rpi->probe_ptr->origin_offset.x;
- reflection_ubo.box_ofs[1]=rpi->probe_ptr->origin_offset.y;
- reflection_ubo.box_ofs[2]=rpi->probe_ptr->origin_offset.z;
- reflection_ubo.box_ofs[3]=0;
-
- reflection_ubo.params[0]=rpi->probe_ptr->intensity;
- reflection_ubo.params[1]=0;
- reflection_ubo.params[2]=rpi->probe_ptr->interior?1.0:0.0;
- reflection_ubo.params[3]=rpi->probe_ptr->box_projection?1.0:0.0;
+ reflection_ubo.params[0] = rpi->probe_ptr->intensity;
+ reflection_ubo.params[1] = 0;
+ reflection_ubo.params[2] = rpi->probe_ptr->interior ? 1.0 : 0.0;
+ reflection_ubo.params[3] = rpi->probe_ptr->box_projection ? 1.0 : 0.0;
if (rpi->probe_ptr->interior) {
Color ambient_linear = rpi->probe_ptr->interior_ambient.to_linear();
- reflection_ubo.ambient[0]=ambient_linear.r*rpi->probe_ptr->interior_ambient_energy;
- reflection_ubo.ambient[1]=ambient_linear.g*rpi->probe_ptr->interior_ambient_energy;
- reflection_ubo.ambient[2]=ambient_linear.b*rpi->probe_ptr->interior_ambient_energy;
- reflection_ubo.ambient[3]=rpi->probe_ptr->interior_ambient_probe_contrib;
+ reflection_ubo.ambient[0] = ambient_linear.r * rpi->probe_ptr->interior_ambient_energy;
+ reflection_ubo.ambient[1] = ambient_linear.g * rpi->probe_ptr->interior_ambient_energy;
+ reflection_ubo.ambient[2] = ambient_linear.b * rpi->probe_ptr->interior_ambient_energy;
+ reflection_ubo.ambient[3] = rpi->probe_ptr->interior_ambient_probe_contrib;
} else {
Color ambient_linear;
- float contrib=0;
+ float contrib = 0;
if (p_env) {
- ambient_linear=p_env->ambient_color.to_linear();
- ambient_linear.r*=p_env->ambient_energy;
- ambient_linear.g*=p_env->ambient_energy;
- ambient_linear.b*=p_env->ambient_energy;
- contrib=p_env->ambient_skybox_contribution;
+ ambient_linear = p_env->ambient_color.to_linear();
+ ambient_linear.r *= p_env->ambient_energy;
+ ambient_linear.g *= p_env->ambient_energy;
+ ambient_linear.b *= p_env->ambient_energy;
+ contrib = p_env->ambient_skybox_contribution;
}
- reflection_ubo.ambient[0]=ambient_linear.r;
- reflection_ubo.ambient[1]=ambient_linear.g;
- reflection_ubo.ambient[2]=ambient_linear.b;
- reflection_ubo.ambient[3]=0;
+ reflection_ubo.ambient[0] = ambient_linear.r;
+ reflection_ubo.ambient[1] = ambient_linear.g;
+ reflection_ubo.ambient[2] = ambient_linear.b;
+ reflection_ubo.ambient[3] = 0;
}
int cell_size = reflection_atlas->size / reflection_atlas->subdiv;
int x = (rpi->reflection_atlas_index % reflection_atlas->subdiv) * cell_size;
int y = (rpi->reflection_atlas_index / reflection_atlas->subdiv) * cell_size;
- int width=cell_size;
- int height=cell_size;
+ int width = cell_size;
+ int height = cell_size;
- reflection_ubo.atlas_clamp[0]=float(x)/reflection_atlas->size;
- reflection_ubo.atlas_clamp[1]=float(y)/reflection_atlas->size;
- reflection_ubo.atlas_clamp[2]=float(width)/reflection_atlas->size;
- reflection_ubo.atlas_clamp[3]=float(height/2)/reflection_atlas->size;
+ reflection_ubo.atlas_clamp[0] = float(x) / reflection_atlas->size;
+ reflection_ubo.atlas_clamp[1] = float(y) / reflection_atlas->size;
+ reflection_ubo.atlas_clamp[2] = float(width) / reflection_atlas->size;
+ reflection_ubo.atlas_clamp[3] = float(height / 2) / reflection_atlas->size;
Transform proj = (p_camera_inverse_transform * rpi->transform).inverse();
- store_transform(proj,reflection_ubo.local_matrix);
+ store_transform(proj, reflection_ubo.local_matrix);
- rpi->reflection_index=state.reflection_probe_count;
- copymem(&state.reflection_array_tmp[rpi->reflection_index*sizeof(ReflectionProbeDataUBO)],&reflection_ubo,sizeof(ReflectionProbeDataUBO));
+ rpi->reflection_index = state.reflection_probe_count;
+ copymem(&state.reflection_array_tmp[rpi->reflection_index * sizeof(ReflectionProbeDataUBO)], &reflection_ubo, sizeof(ReflectionProbeDataUBO));
state.reflection_probe_count++;
-
}
-
if (state.reflection_probe_count) {
-
glBindBuffer(GL_UNIFORM_BUFFER, state.reflection_array_ubo);
- glBufferSubData(GL_UNIFORM_BUFFER, 0, state.reflection_probe_count*sizeof(ReflectionProbeDataUBO), state.reflection_array_tmp);
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, state.reflection_probe_count * sizeof(ReflectionProbeDataUBO), state.reflection_array_tmp);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
}
- glBindBufferBase(GL_UNIFORM_BUFFER,6,state.reflection_array_ubo);
-
+ glBindBufferBase(GL_UNIFORM_BUFFER, 6, state.reflection_array_ubo);
}
-
void RasterizerSceneGLES3::_copy_screen() {
- glBindVertexArray( storage->resources.quadie_array);
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glBindVertexArray(storage->resources.quadie_array);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
-
}
void RasterizerSceneGLES3::_copy_to_front_buffer(Environment *env) {
//copy to front buffer
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDepthFunc(GL_LEQUAL);
- glColorMask(1,1,1,1);
+ glColorMask(1, 1, 1, 1);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.diffuse);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, true);
if (!env) {
//no environment, simply convert from linear to srgb
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, true);
} else {
/* FIXME: Why are both statements equal? */
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
-
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, true);
}
storage->shaders.copy.bind();
_copy_screen();
-
//turn off everything used
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false);
-
-
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, false);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, false);
}
void RasterizerSceneGLES3::_copy_texture_to_front_buffer(GLuint p_texture) {
//copy to front buffer
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDepthFunc(GL_LEQUAL);
- glColorMask(1,1,1,1);
+ glColorMask(1, 1, 1, 1);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,p_texture);
+ glBindTexture(GL_TEXTURE_2D, p_texture);
- glViewport(0,0,storage->frame.current_rt->width*0.5,storage->frame.current_rt->height*0.5);
+ glViewport(0, 0, storage->frame.current_rt->width * 0.5, storage->frame.current_rt->height * 0.5);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, true);
storage->shaders.copy.bind();
_copy_screen();
//turn off everything used
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false);
-
-
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, false);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, false);
}
-void RasterizerSceneGLES3::_fill_render_list(InstanceBase** p_cull_result,int p_cull_count,bool p_shadow){
+void RasterizerSceneGLES3::_fill_render_list(InstanceBase **p_cull_result, int p_cull_count, bool p_shadow) {
- current_geometry_index=0;
- current_material_index=0;
- state.used_sss=false;
+ current_geometry_index = 0;
+ current_material_index = 0;
+ state.used_sss = false;
//fill list
- for(int i=0;i<p_cull_count;i++) {
+ for (int i = 0; i < p_cull_count; i++) {
InstanceBase *inst = p_cull_result[i];
- switch(inst->base_type) {
+ switch (inst->base_type) {
case VS::INSTANCE_MESH: {
@@ -2901,11 +2692,11 @@ void RasterizerSceneGLES3::_fill_render_list(InstanceBase** p_cull_result,int p_
int ssize = mesh->surfaces.size();
- for (int i=0;i<ssize;i++) {
+ 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,p_shadow);
+ _add_geometry(s, inst, NULL, mat_idx, p_shadow);
}
//mesh->last_pass=frame;
@@ -2916,8 +2707,7 @@ void RasterizerSceneGLES3::_fill_render_list(InstanceBase** p_cull_result,int p_
RasterizerStorageGLES3::MultiMesh *multi_mesh = storage->multimesh_owner.getptr(inst->base);
ERR_CONTINUE(!multi_mesh);
-
- if (multi_mesh->size==0 || multi_mesh->visible_instances==0)
+ if (multi_mesh->size == 0 || multi_mesh->visible_instances == 0)
continue;
RasterizerStorageGLES3::Mesh *mesh = storage->mesh_owner.getptr(multi_mesh->mesh);
@@ -2926,32 +2716,27 @@ void RasterizerSceneGLES3::_fill_render_list(InstanceBase** p_cull_result,int p_
int ssize = mesh->surfaces.size();
- for (int i=0;i<ssize;i++) {
+ for (int i = 0; i < ssize; i++) {
RasterizerStorageGLES3::Surface *s = mesh->surfaces[i];
- _add_geometry(s,inst,multi_mesh,-1,p_shadow);
+ _add_geometry(s, inst, multi_mesh, -1, p_shadow);
}
-
} break;
case VS::INSTANCE_IMMEDIATE: {
} break;
-
}
}
}
-
-void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_cam_projection) {
-
+void RasterizerSceneGLES3::_render_mrts(Environment *env, const CameraMatrix &p_cam_projection) {
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
-
if (env->ssao_enabled) {
//copy diffuse to front buffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
@@ -2962,87 +2747,83 @@ void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_c
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
//copy from depth, convert to linear
GLint ss[2];
- ss[0]=storage->frame.current_rt->width;
- ss[1]=storage->frame.current_rt->height;
+ ss[0] = storage->frame.current_rt->width;
+ ss[1] = storage->frame.current_rt->height;
- for(int i=0;i<storage->frame.current_rt->effects.ssao.depth_mipmap_fbos.size();i++) {
+ for (int i = 0; i < storage->frame.current_rt->effects.ssao.depth_mipmap_fbos.size(); i++) {
- state.ssao_minify_shader.set_conditional(SsaoMinifyShaderGLES3::MINIFY_START,i==0);
+ state.ssao_minify_shader.set_conditional(SsaoMinifyShaderGLES3::MINIFY_START, i == 0);
state.ssao_minify_shader.bind();
- state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
- state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::SOURCE_MIPMAP,MAX(0,i-1));
- glUniform2iv(state.ssao_minify_shader.get_uniform(SsaoMinifyShaderGLES3::FROM_SIZE),1,ss);
- ss[0]>>=1;
- ss[1]>>=1;
+ state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
+ state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.ssao_minify_shader.set_uniform(SsaoMinifyShaderGLES3::SOURCE_MIPMAP, MAX(0, i - 1));
+ glUniform2iv(state.ssao_minify_shader.get_uniform(SsaoMinifyShaderGLES3::FROM_SIZE), 1, ss);
+ ss[0] >>= 1;
+ ss[1] >>= 1;
glActiveTexture(GL_TEXTURE0);
- if (i==0) {
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ if (i == 0) {
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
} else {
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.linear_depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.ssao.linear_depth);
}
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.depth_mipmap_fbos[i]); //copy to front first
- glViewport(0,0,ss[0],ss[1]);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.ssao.depth_mipmap_fbos[i]); //copy to front first
+ glViewport(0, 0, ss[0], ss[1]);
_copy_screen();
-
}
- ss[0]=storage->frame.current_rt->width;
- ss[1]=storage->frame.current_rt->height;
-
- glViewport(0,0,ss[0],ss[1]);
+ ss[0] = storage->frame.current_rt->width;
+ ss[1] = storage->frame.current_rt->height;
+ glViewport(0, 0, ss[0], ss[1]);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GREATER);
// do SSAO!
- state.ssao_shader.set_conditional(SsaoShaderGLES3::ENABLE_RADIUS2,env->ssao_radius2>0.001);
+ state.ssao_shader.set_conditional(SsaoShaderGLES3::ENABLE_RADIUS2, env->ssao_radius2 > 0.001);
state.ssao_shader.bind();
- state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
- state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- glUniform2iv(state.ssao_shader.get_uniform(SsaoShaderGLES3::SCREEN_SIZE),1,ss);
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ glUniform2iv(state.ssao_shader.get_uniform(SsaoShaderGLES3::SCREEN_SIZE), 1, ss);
float radius = env->ssao_radius;
- state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS,radius);
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS, radius);
float intensity = env->ssao_intensity;
- state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R6,intensity / pow(radius, 6.0f));
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R6, intensity / pow(radius, 6.0f));
- if (env->ssao_radius2>0.001) {
+ if (env->ssao_radius2 > 0.001) {
float radius2 = env->ssao_radius2;
- state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS2,radius2);
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::RADIUS2, radius2);
float intensity2 = env->ssao_intensity2;
- state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R62,intensity2 / pow(radius2, 6.0f));
-
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::INTENSITY_DIV_R62, intensity2 / pow(radius2, 6.0f));
}
- float proj_info[4]={
- -2.0f / (ss[0]*p_cam_projection.matrix[0][0]),
- -2.0f / (ss[1]*p_cam_projection.matrix[1][1]),
- ( 1.0f - p_cam_projection.matrix[0][2]) / p_cam_projection.matrix[0][0],
- ( 1.0f + p_cam_projection.matrix[1][2]) / p_cam_projection.matrix[1][1]
+ float proj_info[4] = {
+ -2.0f / (ss[0] * p_cam_projection.matrix[0][0]),
+ -2.0f / (ss[1] * p_cam_projection.matrix[1][1]),
+ (1.0f - p_cam_projection.matrix[0][2]) / p_cam_projection.matrix[0][0],
+ (1.0f + p_cam_projection.matrix[1][2]) / p_cam_projection.matrix[1][1]
};
- glUniform4fv(state.ssao_shader.get_uniform(SsaoShaderGLES3::PROJ_INFO),1,proj_info);
+ glUniform4fv(state.ssao_shader.get_uniform(SsaoShaderGLES3::PROJ_INFO), 1, proj_info);
float pixels_per_meter = float(p_cam_projection.get_pixels_per_meter(ss[0]));
- state.ssao_shader.set_uniform(SsaoShaderGLES3::PROJ_SCALE,pixels_per_meter);
- state.ssao_shader.set_uniform(SsaoShaderGLES3::BIAS,env->ssao_bias);
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::PROJ_SCALE, pixels_per_meter);
+ state.ssao_shader.set_uniform(SsaoShaderGLES3::BIAS, env->ssao_bias);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.linear_depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.ssao.linear_depth);
glActiveTexture(GL_TEXTURE2);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.effect);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.blur_fbo[0]); //copy to front first
- Color white(1,1,1,1);
- glClearBufferfv(GL_COLOR,0,white.components); // specular
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.ssao.blur_fbo[0]); //copy to front first
+ Color white(1, 1, 1, 1);
+ glClearBufferfv(GL_COLOR, 0, white.components); // specular
_copy_screen();
@@ -3051,22 +2832,21 @@ void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_c
state.ssao_blur_shader.bind();
if (env->ssao_filter) {
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
- state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
- state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- GLint axis[2]={i,1-i};
- glUniform2iv(state.ssao_blur_shader.get_uniform(SsaoBlurShaderGLES3::AXIS),1,axis);
+ state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
+ state.ssao_blur_shader.set_uniform(SsaoBlurShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ GLint axis[2] = { i, 1 - i };
+ glUniform2iv(state.ssao_blur_shader.get_uniform(SsaoBlurShaderGLES3::AXIS), 1, axis);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.blur_red[i]);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.ssao.blur_red[i]);
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.ssao.blur_fbo[1-i]);
- if (i==0) {
- glClearBufferfv(GL_COLOR,0,white.components); // specular
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.ssao.blur_fbo[1 - i]);
+ if (i == 0) {
+ glClearBufferfv(GL_COLOR, 0, white.components); // specular
}
_copy_screen();
-
}
}
@@ -3075,16 +2855,16 @@ void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_c
// just copy diffuse while applying SSAO
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::SSAO_COLOR,env->ssao_color);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::SSAO_COLOR, env->ssao_color);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color); //previous level, since mipmaps[0] starts one level bigger
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->color); //previous level, since mipmaps[0] starts one level bigger
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.ssao.blur_red[0]); //previous level, since mipmaps[0] starts one level bigger
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.ssao.blur_red[0]); //previous level, since mipmaps[0] starts one level bigger
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SSAO_MERGE, false);
} else {
@@ -3096,137 +2876,124 @@ void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_c
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
}
-
- if (state.used_sss) {//sss enabled
+ if (state.used_sss) { //sss enabled
//copy diffuse while performing sss
//copy normal and roughness to effect buffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
glReadBuffer(GL_COLOR_ATTACHMENT3);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->buffers.effect_fbo);
- glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT , GL_NEAREST);
+ glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
- state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_11_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_LOW);
- state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_17_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_MEDIUM);
- state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_25_SAMPLES,subsurface_scatter_quality==SSS_QUALITY_HIGH);
- state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::ENABLE_FOLLOW_SURFACE,subsurface_scatter_follow_surface);
+ state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_11_SAMPLES, subsurface_scatter_quality == SSS_QUALITY_LOW);
+ state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_17_SAMPLES, subsurface_scatter_quality == SSS_QUALITY_MEDIUM);
+ state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::USE_25_SAMPLES, subsurface_scatter_quality == SSS_QUALITY_HIGH);
+ state.sss_shader.set_conditional(SubsurfScatteringShaderGLES3::ENABLE_FOLLOW_SURFACE, subsurface_scatter_follow_surface);
state.sss_shader.bind();
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::MAX_RADIUS,subsurface_scatter_size);
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::FOVY,p_cam_projection.get_fov());
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR,Vector2(1,0));
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::MAX_RADIUS, subsurface_scatter_size);
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::FOVY, p_cam_projection.get_fov());
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR, Vector2(1, 0));
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color);
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.effect);
glActiveTexture(GL_TEXTURE2);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo); //copy to front first
_copy_screen();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
- state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR,Vector2(0,1));
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->color);
+ state.sss_shader.set_uniform(SubsurfScatteringShaderGLES3::DIR, Vector2(0, 1));
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
_copy_screen();
-
}
-
-
if (env->ssr_enabled) {
//copy normal and roughness to effect buffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
glReadBuffer(GL_COLOR_ATTACHMENT2);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->buffers.effect_fbo);
- glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT , GL_NEAREST);
-
+ glBlitFramebuffer(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, 0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
//blur diffuse into effect mipmaps using separatable convolution
//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
- for(int i=0;i<storage->frame.current_rt->effects.mip_maps[1].sizes.size();i++) {
-
+ for (int i = 0; i < storage->frame.current_rt->effects.mip_maps[1].sizes.size(); i++) {
int vp_w = storage->frame.current_rt->effects.mip_maps[1].sizes[i].width;
int vp_h = storage->frame.current_rt->effects.mip_maps[1].sizes[i].height;
- glViewport(0,0,vp_w,vp_h);
+ glViewport(0, 0, vp_w, vp_h);
//horizontal pass
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD, float(i));
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_HORIZONTAL, false);
//vertical pass
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD, float(i));
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[i+1].fbo); //next level, since mipmaps[0] starts one level bigger
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[1].color);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[i + 1].fbo); //next level, since mipmaps[0] starts one level bigger
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GAUSSIAN_VERTICAL, false);
}
-
//perform SSR
- state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::SMOOTH_ACCEL,env->ssr_accel>0 && env->ssr_smooth);
- state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::REFLECT_ROUGHNESS,env->ssr_accel>0 && env->ssr_roughness);
+ state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::SMOOTH_ACCEL, env->ssr_accel > 0 && env->ssr_smooth);
+ state.ssr_shader.set_conditional(ScreenSpaceReflectionShaderGLES3::REFLECT_ROUGHNESS, env->ssr_accel > 0 && env->ssr_roughness);
state.ssr_shader.bind();
int ssr_w = storage->frame.current_rt->effects.mip_maps[1].sizes[0].width;
int ssr_h = storage->frame.current_rt->effects.mip_maps[1].sizes[0].height;
-
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PIXEL_SIZE,Vector2(1.0/(ssr_w*0.5),1.0/(ssr_h*0.5)));
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PROJECTION,p_cam_projection);
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::INVERSE_PROJECTION,p_cam_projection.inverse());
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::VIEWPORT_SIZE,Size2(ssr_w,ssr_h));
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PIXEL_SIZE, Vector2(1.0 / (ssr_w * 0.5), 1.0 / (ssr_h * 0.5)));
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::PROJECTION, p_cam_projection);
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::INVERSE_PROJECTION, p_cam_projection.inverse());
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::VIEWPORT_SIZE, Size2(ssr_w, ssr_h));
//state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::FRAME_INDEX,int(render_pass));
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::FILTER_MIPMAP_LEVELS,float(storage->frame.current_rt->effects.mip_maps[0].sizes.size()));
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::NUM_STEPS,env->ssr_max_steps);
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::ACCELERATION,env->ssr_accel);
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DEPTH_TOLERANCE,env->ssr_depth_tolerance);
- state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DISTANCE_FADE,env->ssr_fade);
-
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::FILTER_MIPMAP_LEVELS, float(storage->frame.current_rt->effects.mip_maps[0].sizes.size()));
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::NUM_STEPS, env->ssr_max_steps);
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::ACCELERATION, env->ssr_accel);
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DEPTH_TOLERANCE, env->ssr_depth_tolerance);
+ state.ssr_shader.set_uniform(ScreenSpaceReflectionShaderGLES3::DISTANCE_FADE, env->ssr_fade);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color);
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.effect);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.effect);
glActiveTexture(GL_TEXTURE2);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[0].fbo);
- glViewport(0,0,ssr_w,ssr_h);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[1].sizes[0].fbo);
+ glViewport(0, 0, ssr_w, ssr_h);
_copy_screen();
- glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
-
+ glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
}
-
-
glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
glReadBuffer(GL_COLOR_ATTACHMENT1);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->fbo);
@@ -3238,46 +3005,43 @@ void RasterizerSceneGLES3::_render_mrts(Environment *env,const CameraMatrix &p_c
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
//copy reflection over diffuse, resolving SSR if needed
- state.resolve_shader.set_conditional(ResolveShaderGLES3::USE_SSR,env->ssr_enabled);
+ state.resolve_shader.set_conditional(ResolveShaderGLES3::USE_SSR, env->ssr_enabled);
state.resolve_shader.bind();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->color);
if (env->ssr_enabled) {
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[1].color);
}
-
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_ONE,GL_ONE); //use additive to accumulate one over the other
+ glBlendFunc(GL_ONE, GL_ONE); //use additive to accumulate one over the other
_copy_screen();
glDisable(GL_BLEND); //end additive
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(0));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD, float(0));
{
GLuint db = GL_COLOR_ATTACHMENT0;
- glDrawBuffers(1,&db);
+ glDrawBuffers(1, &db);
}
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color);
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY,false);
-
-
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::SIMPLE_COPY, false);
}
-void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_cam_projection){
+void RasterizerSceneGLES3::_post_process(Environment *env, const CameraMatrix &p_cam_projection) {
//copy to front buffer
@@ -3286,14 +3050,13 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDepthFunc(GL_LEQUAL);
- glColorMask(1,1,1,1);
+ glColorMask(1, 1, 1, 1);
//turn off everything used
//copy specular to front buffer
//copy diffuse to effect buffer
-
glReadBuffer(GL_COLOR_ATTACHMENT0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo);
@@ -3304,23 +3067,21 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
if (!env) {
//no environment, simply return and convert to SRGB
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,true);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,true);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, true);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, true);
storage->shaders.copy.bind();
_copy_screen();
- storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB,false);
- storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA,false); //compute luminance
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::LINEAR_TO_SRGB, false);
+ storage->shaders.copy.set_conditional(CopyShaderGLES3::DISABLE_ALPHA, false); //compute luminance
return;
-
}
-
//order of operation
//1) DOF Blur (first blur, then copy to buffer applying the blur)
//2) Motion Blur
@@ -3330,7 +3091,6 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
GLuint composite_from = storage->frame.current_rt->effects.mip_maps[0].color;
-
if (env->dof_blur_far_enabled) {
//blur diffuse into effect mipmaps using separatable convolution
@@ -3339,54 +3099,51 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
int vp_h = storage->frame.current_rt->height;
int vp_w = storage->frame.current_rt->width;
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,true);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_LOW);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,env->dof_blur_far_quality==VS::ENV_DOF_BLUR_QUALITY_HIGH);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR, true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW, env->dof_blur_far_quality == VS::ENV_DOF_BLUR_QUALITY_LOW);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM, env->dof_blur_far_quality == VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH, env->dof_blur_far_quality == VS::ENV_DOF_BLUR_QUALITY_HIGH);
state.effect_blur_shader.bind();
- int qsteps[3]={4,10,20};
+ int qsteps[3] = { 4, 10, 20 };
- float radius = (env->dof_blur_far_amount*env->dof_blur_far_amount) / qsteps[env->dof_blur_far_quality];
+ float radius = (env->dof_blur_far_amount * env->dof_blur_far_amount) / qsteps[env->dof_blur_far_quality];
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_far_distance);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_far_distance+env->dof_blur_far_transition);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(1,0));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN, env->dof_blur_far_distance);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END, env->dof_blur_far_distance + env->dof_blur_far_transition);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR, Vector2(1, 0));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS, radius);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,composite_from);
+ glBindTexture(GL_TEXTURE_2D, composite_from);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo); //copy to front first
_copy_screen();
-
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(0,1));
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->color);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR, Vector2(0, 1));
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,false);
-
-
- composite_from=storage->frame.current_rt->effects.mip_maps[0].color;
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_FAR_BLUR, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH, false);
+ composite_from = storage->frame.current_rt->effects.mip_maps[0].color;
}
if (env->dof_blur_near_enabled) {
@@ -3397,59 +3154,56 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
int vp_h = storage->frame.current_rt->height;
int vp_w = storage->frame.current_rt->width;
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR,true);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR, true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP, true);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_LOW);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,env->dof_blur_near_quality==VS::ENV_DOF_BLUR_QUALITY_HIGH);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW, env->dof_blur_near_quality == VS::ENV_DOF_BLUR_QUALITY_LOW);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM, env->dof_blur_near_quality == VS::ENV_DOF_BLUR_QUALITY_MEDIUM);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH, env->dof_blur_near_quality == VS::ENV_DOF_BLUR_QUALITY_HIGH);
state.effect_blur_shader.bind();
- int qsteps[3]={4,10,20};
+ int qsteps[3] = { 4, 10, 20 };
- float radius = (env->dof_blur_near_amount*env->dof_blur_near_amount) / qsteps[env->dof_blur_near_quality];
+ float radius = (env->dof_blur_near_amount * env->dof_blur_near_amount) / qsteps[env->dof_blur_near_quality];
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_near_distance);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_near_distance-env->dof_blur_near_transition);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(1,0));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN, env->dof_blur_near_distance);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END, env->dof_blur_near_distance - env->dof_blur_near_transition);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR, Vector2(1, 0));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS, radius);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,composite_from);
+ glBindTexture(GL_TEXTURE_2D, composite_from);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo); //copy to front first
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo); //copy to front first
_copy_screen();
//manually do the blend if this is the first operation resolving from the diffuse buffer
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE,composite_from == storage->frame.current_rt->buffers.diffuse);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE, composite_from == storage->frame.current_rt->buffers.diffuse);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP, false);
state.effect_blur_shader.bind();
-
-
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN,env->dof_blur_near_distance);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END,env->dof_blur_near_distance-env->dof_blur_near_transition);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR,Vector2(0,1));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS,radius);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR,p_cam_projection.get_z_near());
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR,p_cam_projection.get_z_far());
-
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_BEGIN, env->dof_blur_near_distance);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_END, env->dof_blur_near_distance - env->dof_blur_near_transition);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_DIR, Vector2(0, 1));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::DOF_RADIUS, radius);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_NEAR, p_cam_projection.get_z_near());
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::CAMERA_Z_FAR, p_cam_projection.get_z_far());
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->color);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[0].fbo); // copy to base level
if (composite_from != storage->frame.current_rt->buffers.diffuse) {
@@ -3459,8 +3213,7 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
} else {
glActiveTexture(GL_TEXTURE2);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
-
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.diffuse);
}
_copy_screen();
@@ -3470,302 +3223,270 @@ void RasterizerSceneGLES3::_post_process(Environment *env,const CameraMatrix &p_
glDisable(GL_BLEND);
}
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH,false);
-
-
- composite_from=storage->frame.current_rt->effects.mip_maps[0].color;
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_FIRST_TAP, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_NEAR_BLUR_MERGE, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_LOW, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_MEDIUM, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::DOF_QUALITY_HIGH, false);
+ composite_from = storage->frame.current_rt->effects.mip_maps[0].color;
}
- if ( env->auto_exposure) {
+ if (env->auto_exposure) {
//compute auto exposure
//first step, copy from image to luminance buffer
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN,true);
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN, true);
state.exposure_shader.bind();
- int ss[2]={
+ int ss[2] = {
storage->frame.current_rt->width,
storage->frame.current_rt->height,
};
- int ds[2]={
+ int ds[2] = {
exposure_shrink_size,
exposure_shrink_size,
};
- glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::SOURCE_RENDER_SIZE),1,ss);
- glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::TARGET_SIZE),1,ds);
+ glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::SOURCE_RENDER_SIZE), 1, ss);
+ glUniform2iv(state.exposure_shader.get_uniform(ExposureShaderGLES3::TARGET_SIZE), 1, ds);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->buffers.diffuse);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->buffers.diffuse);
-
- glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[0].fbo);
- glViewport(0,0,exposure_shrink_size,exposure_shrink_size);
+ glBindFramebuffer(GL_FRAMEBUFFER, exposure_shrink[0].fbo);
+ glViewport(0, 0, exposure_shrink_size, exposure_shrink_size);
_copy_screen();
-
-
-
-
//second step, shrink to 2x2 pixels
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN,false);
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_BEGIN, false);
state.exposure_shader.bind();
//shrink from second to previous to last level
- int s_size=exposure_shrink_size/3;
- for(int i=1;i<exposure_shrink.size()-1;i++) {
+ int s_size = exposure_shrink_size / 3;
+ for (int i = 1; i < exposure_shrink.size() - 1; i++) {
- glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[i].fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, exposure_shrink[i].fbo);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,exposure_shrink[i-1].color);
+ glBindTexture(GL_TEXTURE_2D, exposure_shrink[i - 1].color);
_copy_screen();
- glViewport(0,0,s_size,s_size);
-
- s_size/=3;
+ glViewport(0, 0, s_size, s_size);
+ s_size /= 3;
}
//third step, shrink to 1x1 pixel taking in consideration the previous exposure
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END,true);
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END, true);
uint64_t tick = OS::get_singleton()->get_ticks_usec();
- uint64_t tick_diff = storage->frame.current_rt->last_exposure_tick==0?0:tick-storage->frame.current_rt->last_exposure_tick;
- storage->frame.current_rt->last_exposure_tick=tick;
-
- if (tick_diff==0 || tick_diff>1000000) {
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET,true);
+ uint64_t tick_diff = storage->frame.current_rt->last_exposure_tick == 0 ? 0 : tick - storage->frame.current_rt->last_exposure_tick;
+ storage->frame.current_rt->last_exposure_tick = tick;
+ if (tick_diff == 0 || tick_diff > 1000000) {
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET, true);
}
state.exposure_shader.bind();
- glBindFramebuffer(GL_FRAMEBUFFER,exposure_shrink[exposure_shrink.size()-1].fbo);
- glViewport(0,0,1,1);
+ glBindFramebuffer(GL_FRAMEBUFFER, exposure_shrink[exposure_shrink.size() - 1].fbo);
+ glViewport(0, 0, 1, 1);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,exposure_shrink[exposure_shrink.size()-2].color);
+ glBindTexture(GL_TEXTURE_2D, exposure_shrink[exposure_shrink.size() - 2].color);
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color); //read from previous
-
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->exposure.color); //read from previous
- state.exposure_shader.set_uniform(ExposureShaderGLES3::EXPOSURE_ADJUST,env->auto_exposure_speed*(tick_diff/1000000.0));
- state.exposure_shader.set_uniform(ExposureShaderGLES3::MAX_LUMINANCE,env->auto_exposure_max);
- state.exposure_shader.set_uniform(ExposureShaderGLES3::MIN_LUMINANCE,env->auto_exposure_min);
+ state.exposure_shader.set_uniform(ExposureShaderGLES3::EXPOSURE_ADJUST, env->auto_exposure_speed * (tick_diff / 1000000.0));
+ state.exposure_shader.set_uniform(ExposureShaderGLES3::MAX_LUMINANCE, env->auto_exposure_max);
+ state.exposure_shader.set_uniform(ExposureShaderGLES3::MIN_LUMINANCE, env->auto_exposure_min);
_copy_screen();
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET,false);
- state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END,false);
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_FORCE_SET, false);
+ state.exposure_shader.set_conditional(ExposureShaderGLES3::EXPOSURE_END, false);
//last step, swap with the framebuffer exposure, so the right exposure is kept int he framebuffer
- SWAP(exposure_shrink[exposure_shrink.size()-1].fbo,storage->frame.current_rt->exposure.fbo);
- SWAP(exposure_shrink[exposure_shrink.size()-1].color,storage->frame.current_rt->exposure.color);
-
-
- glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+ SWAP(exposure_shrink[exposure_shrink.size() - 1].fbo, storage->frame.current_rt->exposure.fbo);
+ SWAP(exposure_shrink[exposure_shrink.size() - 1].color, storage->frame.current_rt->exposure.color);
+ glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
}
-
- int max_glow_level=-1;
- int glow_mask=0;
-
+ int max_glow_level = -1;
+ int glow_mask = 0;
if (env->glow_enabled) {
+ for (int i = 0; i < VS::MAX_GLOW_LEVELS; i++) {
+ if (env->glow_levels & (1 << i)) {
- for(int i=0;i<VS::MAX_GLOW_LEVELS;i++) {
- if (env->glow_levels&(1<<i)) {
-
- if (i>=storage->frame.current_rt->effects.mip_maps[1].sizes.size()) {
- max_glow_level=storage->frame.current_rt->effects.mip_maps[1].sizes.size()-1;
- glow_mask|=1<<max_glow_level;
+ if (i >= storage->frame.current_rt->effects.mip_maps[1].sizes.size()) {
+ max_glow_level = storage->frame.current_rt->effects.mip_maps[1].sizes.size() - 1;
+ glow_mask |= 1 << max_glow_level;
} else {
- max_glow_level=i;
- glow_mask|=(1<<i);
+ max_glow_level = i;
+ glow_mask |= (1 << i);
}
-
}
}
-
//blur diffuse into effect mipmaps using separatable convolution
//storage->shaders.copy.set_conditional(CopyShaderGLES3::GAUSSIAN_HORIZONTAL,true);
- for(int i=0;i<(max_glow_level+1);i++) {
-
+ for (int i = 0; i < (max_glow_level + 1); i++) {
int vp_w = storage->frame.current_rt->effects.mip_maps[1].sizes[i].width;
int vp_h = storage->frame.current_rt->effects.mip_maps[1].sizes[i].height;
- glViewport(0,0,vp_w,vp_h);
+ glViewport(0, 0, vp_w, vp_h);
//horizontal pass
- if (i==0) {
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS,true);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE,env->auto_exposure);
+ if (i == 0) {
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS, true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE, env->auto_exposure);
}
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH,env->glow_strength);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD, float(i));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH, env->glow_strength);
glActiveTexture(GL_TEXTURE0);
- if (i==0) {
- glBindTexture(GL_TEXTURE_2D,composite_from);
+ if (i == 0) {
+ glBindTexture(GL_TEXTURE_2D, composite_from);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::EXPOSURE,env->tone_mapper_exposure);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::EXPOSURE, env->tone_mapper_exposure);
if (env->auto_exposure) {
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::AUTO_EXPOSURE_GREY,env->auto_exposure_grey);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::AUTO_EXPOSURE_GREY, env->auto_exposure_grey);
}
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->exposure.color);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_BLOOM,env->glow_bloom);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_TRESHOLD,env->glow_hdr_bleed_treshold);
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_SCALE,env->glow_hdr_bleed_scale);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_BLOOM, env->glow_bloom);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_TRESHOLD, env->glow_hdr_bleed_treshold);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_HDR_SCALE, env->glow_hdr_bleed_scale);
} else {
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color); //previous level, since mipmaps[0] starts one level bigger
}
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[1].sizes[i].fbo);
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS,false);
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_HORIZONTAL, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_FIRST_PASS, false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_USE_AUTO_EXPOSURE, false);
//vertical pass
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL,true);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL, true);
state.effect_blur_shader.bind();
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE,Vector2(1.0/vp_w,1.0/vp_h));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD,float(i));
- state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH,env->glow_strength);
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::PIXEL_SIZE, Vector2(1.0 / vp_w, 1.0 / vp_h));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::LOD, float(i));
+ state.effect_blur_shader.set_uniform(EffectBlurShaderGLES3::GLOW_STRENGTH, env->glow_strength);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[1].color);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->effects.mip_maps[0].sizes[i+1].fbo); //next level, since mipmaps[0] starts one level bigger
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[1].color);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->effects.mip_maps[0].sizes[i + 1].fbo); //next level, since mipmaps[0] starts one level bigger
_copy_screen();
- state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL,false);
+ state.effect_blur_shader.set_conditional(EffectBlurShaderGLES3::GLOW_GAUSSIAN_VERTICAL, false);
}
- glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
-
+ glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
}
-
-
-
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,composite_from);
-
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_FILMIC);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_ACES);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER,env->tone_mapper==VS::ENV_TONE_MAPPER_REINHARDT);
+ glBindTexture(GL_TEXTURE_2D, composite_from);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE,env->auto_exposure);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC,env->glow_bicubic_upscale);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER, env->tone_mapper == VS::ENV_TONE_MAPPER_FILMIC);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER, env->tone_mapper == VS::ENV_TONE_MAPPER_ACES);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER, env->tone_mapper == VS::ENV_TONE_MAPPER_REINHARDT);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE, env->auto_exposure);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC, env->glow_bicubic_upscale);
+ if (max_glow_level >= 0) {
- if (max_glow_level>=0) {
+ for (int i = 0; i < (max_glow_level + 1); i++) {
-
- for(int i=0;i<(max_glow_level+1);i++) {
-
- if (glow_mask&(1<<i)) {
- if (i==0) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1,true);
+ if (glow_mask & (1 << i)) {
+ if (i == 0) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1, true);
}
- if (i==1) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2,true);
+ if (i == 1) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2, true);
}
- if (i==2) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3,true);
+ if (i == 2) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3, true);
}
- if (i==3) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4,true);
+ if (i == 3) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4, true);
}
- if (i==4) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5,true);
+ if (i == 4) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5, true);
}
- if (i==5) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6,true);
+ if (i == 5) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6, true);
}
- if (i==6) {
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7,true);
+ if (i == 6) {
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7, true);
}
}
}
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN,env->glow_blend_mode==VS::GLOW_BLEND_MODE_SCREEN);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT,env->glow_blend_mode==VS::GLOW_BLEND_MODE_SOFTLIGHT);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE,env->glow_blend_mode==VS::GLOW_BLEND_MODE_REPLACE);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN, env->glow_blend_mode == VS::GLOW_BLEND_MODE_SCREEN);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT, env->glow_blend_mode == VS::GLOW_BLEND_MODE_SOFTLIGHT);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE, env->glow_blend_mode == VS::GLOW_BLEND_MODE_REPLACE);
glActiveTexture(GL_TEXTURE2);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->effects.mip_maps[0].color);
-
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->effects.mip_maps[0].color);
}
state.tonemap_shader.bind();
- state.tonemap_shader.set_uniform(TonemapShaderGLES3::EXPOSURE,env->tone_mapper_exposure);
- state.tonemap_shader.set_uniform(TonemapShaderGLES3::WHITE,env->tone_mapper_exposure_white);
+ state.tonemap_shader.set_uniform(TonemapShaderGLES3::EXPOSURE, env->tone_mapper_exposure);
+ state.tonemap_shader.set_uniform(TonemapShaderGLES3::WHITE, env->tone_mapper_exposure_white);
- if (max_glow_level>=0) {
+ if (max_glow_level >= 0) {
- state.tonemap_shader.set_uniform(TonemapShaderGLES3::GLOW_INTENSITY,env->glow_intensity);
- int ss[2]={
+ state.tonemap_shader.set_uniform(TonemapShaderGLES3::GLOW_INTENSITY, env->glow_intensity);
+ int ss[2] = {
storage->frame.current_rt->width,
storage->frame.current_rt->height,
};
- glUniform2iv(state.tonemap_shader.get_uniform(TonemapShaderGLES3::GLOW_TEXTURE_SIZE),1,ss);
-
+ glUniform2iv(state.tonemap_shader.get_uniform(TonemapShaderGLES3::GLOW_TEXTURE_SIZE), 1, ss);
}
- if (env->auto_exposure) {
+ if (env->auto_exposure) {
glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
- state.tonemap_shader.set_uniform(TonemapShaderGLES3::AUTO_EXPOSURE_GREY,env->auto_exposure_grey);
-
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->exposure.color);
+ state.tonemap_shader.set_uniform(TonemapShaderGLES3::AUTO_EXPOSURE_GREY, env->auto_exposure_grey);
}
-
-
_copy_screen();
//turn off everything used
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT,false);
- state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC,false);
-
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_AUTO_EXPOSURE, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_FILMIC_TONEMAPPER, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_ACES_TONEMAPPER, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_REINDHART_TONEMAPPER, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL1, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL2, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL3, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL4, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL5, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL6, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_LEVEL7, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_REPLACE, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SCREEN, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_SOFTLIGHT, false);
+ state.tonemap_shader.set_conditional(TonemapShaderGLES3::USE_GLOW_FILTER_BICUBIC, false);
}
-void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const 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_reflection_probe_cull_result,int p_reflection_probe_cull_count,RID p_environment,RID p_shadow_atlas,RID p_reflection_atlas,RID p_reflection_probe,int p_reflection_probe_pass){
+void RasterizerSceneGLES3::render_scene(const Transform &p_cam_transform, const 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_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID p_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
//first of all, make a new render pass
render_pass++;
-
//fill up ubo
Environment *env = environment_owner.getornull(p_environment);
@@ -3773,73 +3494,69 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
if (shadow_atlas && shadow_atlas->size) {
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-3);
- glBindTexture(GL_TEXTURE_2D,shadow_atlas->depth);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 3);
+ glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
- state.ubo_data.shadow_atlas_pixel_size[0]=1.0/shadow_atlas->size;
- state.ubo_data.shadow_atlas_pixel_size[1]=1.0/shadow_atlas->size;
+ state.ubo_data.shadow_atlas_pixel_size[0] = 1.0 / shadow_atlas->size;
+ state.ubo_data.shadow_atlas_pixel_size[1] = 1.0 / shadow_atlas->size;
}
-
if (reflection_atlas && reflection_atlas->size) {
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-5);
- glBindTexture(GL_TEXTURE_2D,reflection_atlas->color);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 5);
+ glBindTexture(GL_TEXTURE_2D, reflection_atlas->color);
}
if (p_reflection_probe.is_valid()) {
- state.ubo_data.reflection_multiplier=0.0;
+ state.ubo_data.reflection_multiplier = 0.0;
} else {
- state.ubo_data.reflection_multiplier=1.0;
+ state.ubo_data.reflection_multiplier = 1.0;
}
- state.ubo_data.subsurface_scatter_width=subsurface_scatter_size;
+ state.ubo_data.subsurface_scatter_width = subsurface_scatter_size;
-
- state.ubo_data.shadow_z_offset=0;
- state.ubo_data.shadow_slope_scale=0;
- state.ubo_data.shadow_dual_paraboloid_render_side=0;
- state.ubo_data.shadow_dual_paraboloid_render_zfar=0;
+ state.ubo_data.shadow_z_offset = 0;
+ state.ubo_data.shadow_slope_scale = 0;
+ state.ubo_data.shadow_dual_paraboloid_render_side = 0;
+ state.ubo_data.shadow_dual_paraboloid_render_zfar = 0;
if (storage->frame.current_rt) {
- state.ubo_data.screen_pixel_size[0]=1.0/storage->frame.current_rt->width;
- state.ubo_data.screen_pixel_size[1]=1.0/storage->frame.current_rt->height;
+ state.ubo_data.screen_pixel_size[0] = 1.0 / storage->frame.current_rt->width;
+ state.ubo_data.screen_pixel_size[1] = 1.0 / storage->frame.current_rt->height;
}
- _setup_environment(env,p_cam_projection,p_cam_transform);
+ _setup_environment(env, p_cam_projection, p_cam_transform);
- bool fb_cleared=false;
+ bool fb_cleared = false;
glDepthFunc(GL_LEQUAL);
- state.used_contact_shadows=true;
+ state.used_contact_shadows = true;
- if ( storage->frame.current_rt && true) { //detect with state.used_contact_shadows too
+ if (storage->frame.current_rt && true) { //detect with state.used_contact_shadows too
//pre z pass
-
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
- glDrawBuffers(0,NULL);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+ glDrawBuffers(0, NULL);
- glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+ glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
- glColorMask(0,0,0,0);
+ glColorMask(0, 0, 0, 0);
glClearDepth(1.0f);
glClear(GL_DEPTH_BUFFER_BIT);
-
render_list.clear();
- _fill_render_list(p_cull_result,p_cull_count,true);
+ _fill_render_list(p_cull_result, p_cull_count, true);
render_list.sort_by_depth(false);
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,true);
- _render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,0,false,false,true,false,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH, true);
+ _render_list(render_list.elements, render_list.element_count, p_cam_transform, p_cam_projection, 0, false, false, true, false, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH, false);
- glColorMask(1,1,1,1);
+ glColorMask(1, 1, 1, 1);
if (state.used_contact_shadows) {
@@ -3850,28 +3567,24 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
//bind depth for read
- glActiveTexture(GL_TEXTURE0+storage->config.max_texture_image_units-8);
- glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->depth);
+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 8);
+ glBindTexture(GL_TEXTURE_2D, storage->frame.current_rt->depth);
}
- fb_cleared=true;
+ fb_cleared = true;
render_pass++;
}
-
- _setup_lights(p_light_cull_result,p_light_cull_count,p_cam_transform.affine_inverse(),p_cam_projection,p_shadow_atlas);
- _setup_reflections(p_reflection_probe_cull_result,p_reflection_probe_cull_count,p_cam_transform.affine_inverse(),p_cam_projection,p_reflection_atlas,env);
+ _setup_lights(p_light_cull_result, p_light_cull_count, p_cam_transform.affine_inverse(), p_cam_projection, p_shadow_atlas);
+ _setup_reflections(p_reflection_probe_cull_result, p_reflection_probe_cull_count, p_cam_transform.affine_inverse(), p_cam_projection, p_reflection_atlas, env);
render_list.clear();
+ bool use_mrt = false;
- bool use_mrt=false;
-
-
- _fill_render_list(p_cull_result,p_cull_count,false);
+ _fill_render_list(p_cull_result, p_cull_count, false);
//
-
glEnable(GL_BLEND);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
@@ -3881,45 +3594,42 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
ReflectionProbeInstance *probe = reflection_probe_instance_owner.getornull(p_reflection_probe);
GLuint current_fbo;
-
-
if (probe) {
ReflectionAtlas *ref_atlas = reflection_atlas_owner.getptr(probe->atlas);
ERR_FAIL_COND(!ref_atlas);
- int target_size=ref_atlas->size/ref_atlas->subdiv;
+ int target_size = ref_atlas->size / ref_atlas->subdiv;
- int cubemap_index=reflection_cubemaps.size()-1;
+ int cubemap_index = reflection_cubemaps.size() - 1;
- for(int i=reflection_cubemaps.size()-1;i>=0;i--) {
+ for (int i = reflection_cubemaps.size() - 1; i >= 0; i--) {
//find appropriate cubemap to render to
- if (reflection_cubemaps[i].size>target_size*2)
+ if (reflection_cubemaps[i].size > target_size * 2)
break;
- cubemap_index=i;
+ cubemap_index = i;
}
- current_fbo=reflection_cubemaps[cubemap_index].fbo_id[p_reflection_probe_pass];
- use_mrt=false;
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+ current_fbo = reflection_cubemaps[cubemap_index].fbo_id[p_reflection_probe_pass];
+ use_mrt = false;
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS, false);
- glViewport(0,0,reflection_cubemaps[cubemap_index].size,reflection_cubemaps[cubemap_index].size);
- glBindFramebuffer(GL_FRAMEBUFFER,current_fbo);
+ glViewport(0, 0, reflection_cubemaps[cubemap_index].size, reflection_cubemaps[cubemap_index].size);
+ glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
} else {
use_mrt = state.used_sss || (env && (env->ssao_enabled || env->ssr_enabled)); //only enable MRT rendering if any of these is enabled
- glViewport(0,0,storage->frame.current_rt->width,storage->frame.current_rt->height);
+ glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
if (use_mrt) {
- current_fbo=storage->frame.current_rt->buffers.fbo;
-
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,true);
+ current_fbo = storage->frame.current_rt->buffers.fbo;
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS, true);
Vector<GLenum> draw_buffers;
draw_buffers.push_back(GL_COLOR_ATTACHMENT0);
@@ -3928,27 +3638,24 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
if (state.used_sss) {
draw_buffers.push_back(GL_COLOR_ATTACHMENT3);
}
- glDrawBuffers(draw_buffers.size(),draw_buffers.ptr());
+ glDrawBuffers(draw_buffers.size(), draw_buffers.ptr());
- Color black(0,0,0,0);
- glClearBufferfv(GL_COLOR,1,black.components); // specular
- glClearBufferfv(GL_COLOR,2,black.components); // normal metal rough
+ Color black(0, 0, 0, 0);
+ glClearBufferfv(GL_COLOR, 1, black.components); // specular
+ glClearBufferfv(GL_COLOR, 2, black.components); // normal metal rough
if (state.used_sss) {
- glClearBufferfv(GL_COLOR,3,black.components); // normal metal rough
+ glClearBufferfv(GL_COLOR, 3, black.components); // normal metal rough
}
} else {
-
-
current_fbo = storage->frame.current_rt->buffers.fbo;
- glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo);
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+ glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->buffers.fbo);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS, false);
Vector<GLenum> draw_buffers;
draw_buffers.push_back(GL_COLOR_ATTACHMENT0);
- glDrawBuffers(draw_buffers.size(),draw_buffers.ptr());
-
+ glDrawBuffers(draw_buffers.size(), draw_buffers.ptr());
}
}
@@ -3957,41 +3664,39 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
glClear(GL_DEPTH_BUFFER_BIT);
}
- Color clear_color(0,0,0,0);
+ Color clear_color(0, 0, 0, 0);
- RasterizerStorageGLES3::SkyBox *skybox=NULL;
- GLuint env_radiance_tex=0;
+ RasterizerStorageGLES3::SkyBox *skybox = NULL;
+ GLuint env_radiance_tex = 0;
- if (!env || env->bg_mode==VS::ENV_BG_CLEAR_COLOR) {
+ if (!env || env->bg_mode == VS::ENV_BG_CLEAR_COLOR) {
if (storage->frame.clear_request) {
clear_color = storage->frame.clear_request_color.to_linear();
- storage->frame.clear_request=false;
-
+ storage->frame.clear_request = false;
}
- } else if (env->bg_mode==VS::ENV_BG_COLOR) {
+ } else if (env->bg_mode == VS::ENV_BG_COLOR) {
clear_color = env->bg_color.to_linear();
- storage->frame.clear_request=false;
- } else if (env->bg_mode==VS::ENV_BG_SKYBOX) {
+ storage->frame.clear_request = false;
+ } else if (env->bg_mode == VS::ENV_BG_SKYBOX) {
skybox = storage->skybox_owner.getornull(env->skybox);
if (skybox) {
- env_radiance_tex=skybox->radiance;
+ env_radiance_tex = skybox->radiance;
}
- storage->frame.clear_request=false;
+ storage->frame.clear_request = false;
} else {
- storage->frame.clear_request=false;
+ storage->frame.clear_request = false;
}
- glClearBufferfv(GL_COLOR,0,clear_color.components); // specular
-
+ glClearBufferfv(GL_COLOR, 0, clear_color.components); // specular
- state.texscreen_copied=false;
+ state.texscreen_copied = false;
glBlendEquation(GL_FUNC_ADD);
@@ -4011,53 +3716,44 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
-
-
- if (state.directional_light_count==0) {
- directional_light=NULL;
- _render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,false,false,false,shadow_atlas!=NULL);
+ if (state.directional_light_count == 0) {
+ directional_light = NULL;
+ _render_list(render_list.elements, render_list.element_count, p_cam_transform, p_cam_projection, env_radiance_tex, false, false, false, false, shadow_atlas != NULL);
} else {
- for(int i=0;i<state.directional_light_count;i++) {
- directional_light=directional_lights[i];
- if (i>0) {
+ for (int i = 0; i < state.directional_light_count; i++) {
+ directional_light = directional_lights[i];
+ if (i > 0) {
glEnable(GL_BLEND);
}
- _setup_directional_light(i,p_cam_transform.affine_inverse(),shadow_atlas!=NULL);
- _render_list(render_list.elements,render_list.element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,false,false,i>0,shadow_atlas!=NULL);
-
+ _setup_directional_light(i, p_cam_transform.affine_inverse(), shadow_atlas != NULL);
+ _render_list(render_list.elements, render_list.element_count, p_cam_transform, p_cam_projection, env_radiance_tex, false, false, false, i > 0, shadow_atlas != NULL);
}
}
-
- state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS,false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::USE_MULTIPLE_RENDER_TARGETS, false);
if (use_mrt) {
GLenum gldb = GL_COLOR_ATTACHMENT0;
- glDrawBuffers(1,&gldb);
+ glDrawBuffers(1, &gldb);
}
- if (env && env->bg_mode==VS::ENV_BG_SKYBOX) {
+ if (env && env->bg_mode == VS::ENV_BG_SKYBOX) {
/*
if (use_mrt) {
glBindFramebuffer(GL_FRAMEBUFFER,storage->frame.current_rt->buffers.fbo); //switch to alpha fbo for skybox, only diffuse/ambient matters
*/
- _draw_skybox(skybox,p_cam_projection,p_cam_transform,storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP],env->skybox_scale);
+ _draw_skybox(skybox, p_cam_projection, p_cam_transform, storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_VFLIP], env->skybox_scale);
}
-
-
-
-
//_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);
-
if (use_mrt) {
- _render_mrts(env,p_cam_projection);
+ _render_mrts(env, p_cam_projection);
}
glEnable(GL_BLEND);
@@ -4067,15 +3763,14 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
render_list.sort_by_depth(true);
- if (state.directional_light_count==0) {
- directional_light=NULL;
- _render_list(&render_list.elements[render_list.max_elements-render_list.alpha_element_count],render_list.alpha_element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,true,false,false,shadow_atlas!=NULL);
+ if (state.directional_light_count == 0) {
+ directional_light = NULL;
+ _render_list(&render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, p_cam_transform, p_cam_projection, env_radiance_tex, false, true, false, false, shadow_atlas != NULL);
} else {
- for(int i=0;i<state.directional_light_count;i++) {
- directional_light=directional_lights[i];
- _setup_directional_light(i,p_cam_transform.affine_inverse(),shadow_atlas!=NULL);
- _render_list(&render_list.elements[render_list.max_elements-render_list.alpha_element_count],render_list.alpha_element_count,p_cam_transform,p_cam_projection,env_radiance_tex,false,true,false,i>0,shadow_atlas!=NULL);
-
+ for (int i = 0; i < state.directional_light_count; i++) {
+ directional_light = directional_lights[i];
+ _setup_directional_light(i, p_cam_transform.affine_inverse(), shadow_atlas != NULL);
+ _render_list(&render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, p_cam_transform, p_cam_projection, env_radiance_tex, false, true, false, i > 0, shadow_atlas != NULL);
}
}
@@ -4084,19 +3779,16 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
return;
}
-
- _post_process(env,p_cam_projection);
-
+ _post_process(env, p_cam_projection);
if (false && shadow_atlas) {
//_copy_texture_to_front_buffer(shadow_atlas->depth);
storage->canvas->canvas_begin();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,shadow_atlas->depth);
+ glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
- storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
-
+ storage->canvas->draw_generic_textured_rect(Rect2(0, 0, storage->frame.current_rt->width / 2, storage->frame.current_rt->height / 2), Rect2(0, 0, 1, 1));
}
if (false && storage->frame.current_rt) {
@@ -4104,10 +3796,9 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
//_copy_texture_to_front_buffer(shadow_atlas->depth);
storage->canvas->canvas_begin();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,exposure_shrink[4].color);
+ glBindTexture(GL_TEXTURE_2D, exposure_shrink[4].color);
//glBindTexture(GL_TEXTURE_2D,storage->frame.current_rt->exposure.color);
- storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/16,storage->frame.current_rt->height/16),Rect2(0,0,1,1));
-
+ storage->canvas->draw_generic_textured_rect(Rect2(0, 0, storage->frame.current_rt->width / 16, storage->frame.current_rt->height / 16), Rect2(0, 0, 1, 1));
}
if (false && reflection_atlas && storage->frame.current_rt) {
@@ -4115,9 +3806,8 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
//_copy_texture_to_front_buffer(shadow_atlas->depth);
storage->canvas->canvas_begin();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,reflection_atlas->color);
- storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
-
+ glBindTexture(GL_TEXTURE_2D, reflection_atlas->color);
+ storage->canvas->draw_generic_textured_rect(Rect2(0, 0, storage->frame.current_rt->width / 2, storage->frame.current_rt->height / 2), Rect2(0, 0, 1, 1));
}
if (false && directional_shadow.fbo) {
@@ -4125,10 +3815,9 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
//_copy_texture_to_front_buffer(shadow_atlas->depth);
storage->canvas->canvas_begin();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
+ glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
- storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
-
+ storage->canvas->draw_generic_textured_rect(Rect2(0, 0, storage->frame.current_rt->width / 2, storage->frame.current_rt->height / 2), Rect2(0, 0, 1, 1));
}
if (false && env_radiance_tex) {
@@ -4136,12 +3825,10 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
//_copy_texture_to_front_buffer(shadow_atlas->depth);
storage->canvas->canvas_begin();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,env_radiance_tex);
- storage->canvas->draw_generic_textured_rect(Rect2(0,0,storage->frame.current_rt->width/2,storage->frame.current_rt->height/2),Rect2(0,0,1,1));
-
+ glBindTexture(GL_TEXTURE_2D, env_radiance_tex);
+ storage->canvas->draw_generic_textured_rect(Rect2(0, 0, storage->frame.current_rt->width / 2, storage->frame.current_rt->height / 2), Rect2(0, 0, 1, 1));
}
-
#if 0
if (use_fb) {
@@ -4288,106 +3975,97 @@ void RasterizerSceneGLES3::render_scene(const Transform& p_cam_transform,const C
#endif
}
-void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pass,InstanceBase** p_cull_result,int p_cull_count) {
+void RasterizerSceneGLES3::render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count) {
render_pass++;
- directional_light=NULL;
+ directional_light = NULL;
LightInstance *light_instance = light_instance_owner.getornull(p_light);
ERR_FAIL_COND(!light_instance);
RasterizerStorageGLES3::Light *light = storage->light_owner.getornull(light_instance->light);
ERR_FAIL_COND(!light);
- uint32_t x,y,width,height,vp_height;
-
+ uint32_t x, y, width, height, vp_height;
- float dp_direction=0.0;
- float zfar=0;
- bool flip_facing=false;
- int custom_vp_size=0;
+ float dp_direction = 0.0;
+ float zfar = 0;
+ bool flip_facing = false;
+ int custom_vp_size = 0;
GLuint fbo;
- int current_cubemap=-1;
- float bias=0;
- float normal_bias=0;
+ int current_cubemap = -1;
+ float bias = 0;
+ float normal_bias = 0;
CameraMatrix light_projection;
Transform light_transform;
-
- if (light->type==VS::LIGHT_DIRECTIONAL) {
+ if (light->type == VS::LIGHT_DIRECTIONAL) {
//set pssm stuff
- if (light_instance->last_scene_shadow_pass!=scene_pass) {
+ if (light_instance->last_scene_shadow_pass != scene_pass) {
//assign rect if unassigned
light_instance->light_directional_index = directional_shadow.current_light;
- light_instance->last_scene_shadow_pass=scene_pass;
+ light_instance->last_scene_shadow_pass = scene_pass;
directional_shadow.current_light++;
- if (directional_shadow.light_count==1) {
- light_instance->directional_rect=Rect2(0,0,directional_shadow.size,directional_shadow.size);
- } else if (directional_shadow.light_count==2) {
- light_instance->directional_rect=Rect2(0,0,directional_shadow.size,directional_shadow.size/2);
- if (light_instance->light_directional_index==1) {
- light_instance->directional_rect.pos.x+=light_instance->directional_rect.size.x;
+ if (directional_shadow.light_count == 1) {
+ light_instance->directional_rect = Rect2(0, 0, directional_shadow.size, directional_shadow.size);
+ } else if (directional_shadow.light_count == 2) {
+ light_instance->directional_rect = Rect2(0, 0, directional_shadow.size, directional_shadow.size / 2);
+ if (light_instance->light_directional_index == 1) {
+ light_instance->directional_rect.pos.x += light_instance->directional_rect.size.x;
}
- } else { //3 and 4
- light_instance->directional_rect=Rect2(0,0,directional_shadow.size/2,directional_shadow.size/2);
- if (light_instance->light_directional_index&1) {
- light_instance->directional_rect.pos.x+=light_instance->directional_rect.size.x;
+ } else { //3 and 4
+ light_instance->directional_rect = Rect2(0, 0, directional_shadow.size / 2, directional_shadow.size / 2);
+ if (light_instance->light_directional_index & 1) {
+ light_instance->directional_rect.pos.x += light_instance->directional_rect.size.x;
}
- if (light_instance->light_directional_index/2) {
- light_instance->directional_rect.pos.y+=light_instance->directional_rect.size.y;
+ if (light_instance->light_directional_index / 2) {
+ light_instance->directional_rect.pos.y += light_instance->directional_rect.size.y;
}
}
}
- light_projection=light_instance->shadow_transform[p_pass].camera;
- light_transform=light_instance->shadow_transform[p_pass].transform;
-
- x=light_instance->directional_rect.pos.x;
- y=light_instance->directional_rect.pos.y;
- width=light_instance->directional_rect.size.x;
- height=light_instance->directional_rect.size.y;
-
+ light_projection = light_instance->shadow_transform[p_pass].camera;
+ light_transform = light_instance->shadow_transform[p_pass].transform;
+ x = light_instance->directional_rect.pos.x;
+ y = light_instance->directional_rect.pos.y;
+ width = light_instance->directional_rect.size.x;
+ height = light_instance->directional_rect.size.y;
- if (light->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+ if (light->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+ width /= 2;
+ height /= 2;
- width/=2;
- height/=2;
-
- if (p_pass==0) {
-
- } else if (p_pass==1) {
- x+=width;
- } else if (p_pass==2) {
- y+=height;
- } else if (p_pass==3) {
- x+=width;
- y+=height;
+ if (p_pass == 0) {
+ } else if (p_pass == 1) {
+ x += width;
+ } else if (p_pass == 2) {
+ y += height;
+ } else if (p_pass == 3) {
+ x += width;
+ y += height;
}
+ } else if (light->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+ height /= 2;
- } else if (light->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
-
- height/=2;
-
- if (p_pass==0) {
+ if (p_pass == 0) {
} else {
- y+=height;
+ y += height;
}
-
}
- zfar=light->param[VS::LIGHT_PARAM_RANGE];
- bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
- normal_bias=light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
- fbo=directional_shadow.fbo;
- vp_height=directional_shadow.size;
+ zfar = light->param[VS::LIGHT_PARAM_RANGE];
+ bias = light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+ normal_bias = light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
+ fbo = directional_shadow.fbo;
+ vp_height = directional_shadow.size;
} else {
//set from shadow atlas
@@ -4396,112 +4074,106 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
ERR_FAIL_COND(!shadow_atlas);
ERR_FAIL_COND(!shadow_atlas->shadow_owners.has(p_light));
- fbo=shadow_atlas->fbo;
- vp_height=shadow_atlas->size;
+ 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;
+ uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
- ERR_FAIL_INDEX(shadow,shadow_atlas->quadrants[quadrant].shadows.size());
+ ERR_FAIL_INDEX(shadow, shadow_atlas->quadrants[quadrant].shadows.size());
- uint32_t quadrant_size = shadow_atlas->size>>1;
+ uint32_t quadrant_size = shadow_atlas->size >> 1;
- x=(quadrant&1)*quadrant_size;
- y=(quadrant>>1)*quadrant_size;
+ x = (quadrant & 1) * quadrant_size;
+ y = (quadrant >> 1) * quadrant_size;
uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
- x+=(shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- y+=(shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
-
- width=shadow_size;
- height=shadow_size;
+ x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+ y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
- if (light->type==VS::LIGHT_OMNI) {
+ width = shadow_size;
+ height = shadow_size;
+ if (light->type == VS::LIGHT_OMNI) {
- if (light->omni_shadow_mode==VS::LIGHT_OMNI_SHADOW_CUBE) {
+ if (light->omni_shadow_mode == VS::LIGHT_OMNI_SHADOW_CUBE) {
- int cubemap_index=shadow_cubemaps.size()-1;
+ int cubemap_index = shadow_cubemaps.size() - 1;
- for(int i=shadow_cubemaps.size()-1;i>=0;i--) {
+ for (int i = shadow_cubemaps.size() - 1; i >= 0; i--) {
//find appropriate cubemap to render to
- if (shadow_cubemaps[i].size>shadow_size*2)
+ if (shadow_cubemaps[i].size > shadow_size * 2)
break;
- cubemap_index=i;
+ cubemap_index = i;
}
- fbo=shadow_cubemaps[cubemap_index].fbo_id[p_pass];
- light_projection=light_instance->shadow_transform[0].camera;
- light_transform=light_instance->shadow_transform[0].transform;
- custom_vp_size=shadow_cubemaps[cubemap_index].size;
- zfar=light->param[VS::LIGHT_PARAM_RANGE];
-
- current_cubemap=cubemap_index;
+ fbo = shadow_cubemaps[cubemap_index].fbo_id[p_pass];
+ light_projection = light_instance->shadow_transform[0].camera;
+ light_transform = light_instance->shadow_transform[0].transform;
+ custom_vp_size = shadow_cubemaps[cubemap_index].size;
+ zfar = light->param[VS::LIGHT_PARAM_RANGE];
+ current_cubemap = cubemap_index;
} else {
- light_projection=light_instance->shadow_transform[0].camera;
- light_transform=light_instance->shadow_transform[0].transform;
+ light_projection = light_instance->shadow_transform[0].camera;
+ light_transform = light_instance->shadow_transform[0].transform;
- if (light->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+ if (light->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
- height/=2;
- y+=p_pass*height;
+ height /= 2;
+ y += p_pass * height;
} else {
- width/=2;
- x+=p_pass*width;
-
+ width /= 2;
+ x += p_pass * width;
}
- dp_direction = p_pass==0?1.0:-1.0;
+ dp_direction = p_pass == 0 ? 1.0 : -1.0;
flip_facing = (p_pass == 1);
- zfar=light->param[VS::LIGHT_PARAM_RANGE];
- bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+ zfar = light->param[VS::LIGHT_PARAM_RANGE];
+ bias = light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID,true);
+ state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID, true);
}
- } else if (light->type==VS::LIGHT_SPOT) {
+ } else if (light->type == VS::LIGHT_SPOT) {
- light_projection=light_instance->shadow_transform[0].camera;
- light_transform=light_instance->shadow_transform[0].transform;
+ light_projection = light_instance->shadow_transform[0].camera;
+ light_transform = light_instance->shadow_transform[0].transform;
dp_direction = 1.0;
flip_facing = false;
- zfar=light->param[VS::LIGHT_PARAM_RANGE];
- bias=light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
- normal_bias=light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
+ zfar = light->param[VS::LIGHT_PARAM_RANGE];
+ bias = light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+ normal_bias = light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS];
}
-
}
//todo hacer que se redibuje cuando corresponde
-
render_list.clear();
- _fill_render_list(p_cull_result,p_cull_count,true);
+ _fill_render_list(p_cull_result, p_cull_count, true);
render_list.sort_by_depth(false); //shadow is front to back for performance
glDisable(GL_BLEND);
glDisable(GL_DITHER);
glEnable(GL_DEPTH_TEST);
- glBindFramebuffer(GL_FRAMEBUFFER,fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glDepthMask(true);
- glColorMask(0,0,0,0);
-
+ glColorMask(0, 0, 0, 0);
if (custom_vp_size) {
- glViewport(0,0,custom_vp_size,custom_vp_size);
- glScissor(0,0,custom_vp_size,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, y, width, height);
+ glScissor(x, y, width, height);
}
glEnable(GL_SCISSOR_TEST);
@@ -4509,54 +4181,53 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
- state.ubo_data.shadow_z_offset=bias;
- state.ubo_data.shadow_slope_scale=normal_bias;
- state.ubo_data.shadow_dual_paraboloid_render_side=dp_direction;
- state.ubo_data.shadow_dual_paraboloid_render_zfar=zfar;
-
- _setup_environment(NULL,light_projection,light_transform);
+ state.ubo_data.shadow_z_offset = bias;
+ state.ubo_data.shadow_slope_scale = normal_bias;
+ state.ubo_data.shadow_dual_paraboloid_render_side = dp_direction;
+ state.ubo_data.shadow_dual_paraboloid_render_zfar = zfar;
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,true);
+ _setup_environment(NULL, light_projection, light_transform);
- _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_DEPTH, true);
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH,false);
- state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID,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_DEPTH, false);
+ state.scene_shader.set_conditional(SceneShaderGLES3::RENDER_DEPTH_DUAL_PARABOLOID, false);
- if (light->type==VS::LIGHT_OMNI && light->omni_shadow_mode==VS::LIGHT_OMNI_SHADOW_CUBE && p_pass==5) {
+ if (light->type == VS::LIGHT_OMNI && light->omni_shadow_mode == VS::LIGHT_OMNI_SHADOW_CUBE && p_pass == 5) {
//convert the chosen cubemap to dual paraboloid!
ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
- glBindFramebuffer(GL_FRAMEBUFFER,shadow_atlas->fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, shadow_atlas->fbo);
state.cube_to_dp_shader.bind();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_CUBE_MAP,shadow_cubemaps[current_cubemap].cubemap);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, shadow_cubemaps[current_cubemap].cubemap);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_NONE);
glDisable(GL_CULL_FACE);
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
- state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FLIP,i==1);
- state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_NEAR,light_projection.get_z_near());
- state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FAR,light_projection.get_z_far());
- state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::BIAS,light->param[VS::LIGHT_PARAM_SHADOW_BIAS]);
+ state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FLIP, i == 1);
+ state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_NEAR, light_projection.get_z_near());
+ state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::Z_FAR, light_projection.get_z_far());
+ state.cube_to_dp_shader.set_uniform(CubeToDpShaderGLES3::BIAS, light->param[VS::LIGHT_PARAM_SHADOW_BIAS]);
- uint32_t local_width=width,local_height=height;
- uint32_t local_x=x,local_y=y;
- if (light->omni_shadow_detail==VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+ uint32_t local_width = width, local_height = height;
+ uint32_t local_x = x, local_y = y;
+ if (light->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
- local_height/=2;
- local_y+=i*local_height;
+ local_height /= 2;
+ local_y += i * local_height;
} else {
- local_width/=2;
- local_x+=i*local_width;
+ local_width /= 2;
+ local_x += i * local_width;
}
- glViewport(local_x,local_y,local_width,local_height);
- glScissor(local_x,local_y,local_width,local_height);
+ glViewport(local_x, local_y, local_width, local_height);
+ glScissor(local_x, local_y, local_width, local_height);
glEnable(GL_SCISSOR_TEST);
glClearDepth(1.0f);
glClear(GL_DEPTH_BUFFER_BIT);
@@ -4565,53 +4236,47 @@ void RasterizerSceneGLES3::render_shadow(RID p_light,RID p_shadow_atlas,int p_pa
glDisable(GL_BLEND);
_copy_screen();
-
}
-
}
- glColorMask(1,1,1,1);
-
-
+ glColorMask(1, 1, 1, 1);
}
void RasterizerSceneGLES3::set_scene_pass(uint64_t p_pass) {
- scene_pass=p_pass;
+ scene_pass = p_pass;
}
bool RasterizerSceneGLES3::free(RID p_rid) {
if (light_instance_owner.owns(p_rid)) {
-
LightInstance *light_instance = light_instance_owner.getptr(p_rid);
//remove from shadow atlases..
- for(Set<RID>::Element *E=light_instance->shadow_atlases.front();E;E=E->next()) {
+ for (Set<RID>::Element *E = light_instance->shadow_atlases.front(); E; E = E->next()) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(E->get());
ERR_CONTINUE(!shadow_atlas->shadow_owners.has(p_rid));
uint32_t key = shadow_atlas->shadow_owners[p_rid];
- uint32_t q = (key>>ShadowAtlas::QUADRANT_SHIFT)&0x3;
- uint32_t s = key&ShadowAtlas::SHADOW_INDEX_MASK;
+ uint32_t q = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
+ uint32_t s = key & ShadowAtlas::SHADOW_INDEX_MASK;
- shadow_atlas->quadrants[q].shadows[s].owner=RID();
+ shadow_atlas->quadrants[q].shadows[s].owner = RID();
shadow_atlas->shadow_owners.erase(p_rid);
}
-
light_instance_owner.free(p_rid);
memdelete(light_instance);
} else if (shadow_atlas_owner.owns(p_rid)) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(p_rid);
- shadow_atlas_set_size(p_rid,0);
+ shadow_atlas_set_size(p_rid, 0);
shadow_atlas_owner.free(p_rid);
memdelete(shadow_atlas);
} else if (reflection_atlas_owner.owns(p_rid)) {
ReflectionAtlas *reflection_atlas = reflection_atlas_owner.get(p_rid);
- reflection_atlas_set_size(p_rid,0);
+ reflection_atlas_set_size(p_rid, 0);
reflection_atlas_owner.free(p_rid);
memdelete(reflection_atlas);
} else if (reflection_probe_instance_owner.owns(p_rid)) {
@@ -4626,46 +4291,44 @@ bool RasterizerSceneGLES3::free(RID p_rid) {
return false;
}
-
return true;
-
}
// http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
static _FORCE_INLINE_ float radicalInverse_VdC(uint32_t bits) {
- bits = (bits << 16u) | (bits >> 16u);
- bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
- bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
- bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
- bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
- return float(bits) * 2.3283064365386963e-10f; // / 0x100000000
+ bits = (bits << 16u) | (bits >> 16u);
+ bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+ bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+ bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+ bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+ return float(bits) * 2.3283064365386963e-10f; // / 0x100000000
}
static _FORCE_INLINE_ Vector2 Hammersley(uint32_t i, uint32_t N) {
- return Vector2(float(i) / float(N), radicalInverse_VdC(i));
+ return Vector2(float(i) / float(N), radicalInverse_VdC(i));
}
static _FORCE_INLINE_ Vector3 ImportanceSampleGGX(Vector2 Xi, float Roughness, Vector3 N) {
- float a = Roughness * Roughness; // DISNEY'S ROUGHNESS [see Burley'12 siggraph]
+ float a = Roughness * Roughness; // DISNEY'S ROUGHNESS [see Burley'12 siggraph]
- // Compute distribution direction
- float Phi = 2.0f * Math_PI * Xi.x;
- float CosTheta = Math::sqrt((float)(1.0f - Xi.y) / (1.0f + (a*a - 1.0f) * Xi.y));
- float SinTheta = Math::sqrt((float)Math::abs(1.0f - CosTheta * CosTheta));
+ // Compute distribution direction
+ float Phi = 2.0f * Math_PI * Xi.x;
+ float CosTheta = Math::sqrt((float)(1.0f - Xi.y) / (1.0f + (a * a - 1.0f) * Xi.y));
+ float SinTheta = Math::sqrt((float)Math::abs(1.0f - CosTheta * CosTheta));
- // Convert to spherical direction
- Vector3 H;
- H.x = SinTheta * Math::cos(Phi);
- H.y = SinTheta * Math::sin(Phi);
- H.z = CosTheta;
+ // Convert to spherical direction
+ Vector3 H;
+ H.x = SinTheta * Math::cos(Phi);
+ H.y = SinTheta * Math::sin(Phi);
+ H.z = CosTheta;
- Vector3 UpVector = Math::abs(N.z) < 0.999 ? Vector3(0.0, 0.0, 1.0) : Vector3(1.0, 0.0, 0.0);
- Vector3 TangentX = UpVector.cross(N);
- TangentX.normalize();
- Vector3 TangentY = N.cross(TangentX);
+ Vector3 UpVector = Math::abs(N.z) < 0.999 ? Vector3(0.0, 0.0, 1.0) : Vector3(1.0, 0.0, 0.0);
+ Vector3 TangentX = UpVector.cross(N);
+ TangentX.normalize();
+ Vector3 TangentY = N.cross(TangentX);
- // Tangent to world space
- return TangentX * H.x + TangentY * H.y + N * H.z;
+ // Tangent to world space
+ return TangentX * H.x + TangentY * H.y + N * H.z;
}
static _FORCE_INLINE_ float GGX(float NdotV, float a) {
@@ -4674,31 +4337,27 @@ static _FORCE_INLINE_ float GGX(float NdotV, float a) {
}
// http://graphicrants.blogspot.com.au/2013/08/specular-brdf-reference.html
-float _FORCE_INLINE_ G_Smith(float a, float nDotV, float nDotL)
-{
+float _FORCE_INLINE_ G_Smith(float a, float nDotV, float nDotL) {
return GGX(nDotL, a * a) * GGX(nDotV, a * a);
}
void RasterizerSceneGLES3::_generate_brdf() {
- int brdf_size=GLOBAL_DEF("rendering/gles3/brdf_texture_size",64);
-
-
+ int brdf_size = GLOBAL_DEF("rendering/gles3/brdf_texture_size", 64);
PoolVector<uint8_t> brdf;
- brdf.resize(brdf_size*brdf_size*2);
+ brdf.resize(brdf_size * brdf_size * 2);
PoolVector<uint8_t>::Write w = brdf.write();
+ for (int i = 0; i < brdf_size; i++) {
+ for (int j = 0; j < brdf_size; j++) {
- for(int i=0;i<brdf_size;i++) {
- for(int j=0;j<brdf_size;j++) {
-
- float Roughness = float(j)/(brdf_size-1);
- float NoV = float(i+1)/(brdf_size); //avoid storing nov0
+ float Roughness = float(j) / (brdf_size - 1);
+ float NoV = float(i + 1) / (brdf_size); //avoid storing nov0
Vector3 V;
- V.x = Math::sqrt( 1.0f - NoV * NoV );
+ V.x = Math::sqrt(1.0f - NoV * NoV);
V.y = 0.0;
V.z = NoV;
@@ -4707,69 +4366,63 @@ void RasterizerSceneGLES3::_generate_brdf() {
float A = 0;
float B = 0;
- for(int s=0;s<512;s++) {
+ for (int s = 0; s < 512; s++) {
+ Vector2 xi = Hammersley(s, 512);
+ Vector3 H = ImportanceSampleGGX(xi, Roughness, N);
+ Vector3 L = 2.0 * V.dot(H) * H - V;
- Vector2 xi = Hammersley(s,512);
- Vector3 H = ImportanceSampleGGX( xi, Roughness, N );
- Vector3 L = 2.0 * V.dot(H) * H - V;
+ float NoL = CLAMP(L.z, 0.0, 1.0);
+ float NoH = CLAMP(H.z, 0.0, 1.0);
+ float VoH = CLAMP(V.dot(H), 0.0, 1.0);
- float NoL = CLAMP( L.z, 0.0, 1.0 );
- float NoH = CLAMP( H.z, 0.0, 1.0 );
- float VoH = CLAMP( V.dot(H), 0.0, 1.0 );
-
- if ( NoL > 0.0 ) {
- float G = G_Smith( Roughness, NoV, NoL );
+ if (NoL > 0.0) {
+ float G = G_Smith(Roughness, NoV, NoL);
float G_Vis = G * VoH / (NoH * NoV);
- float Fc = pow(1.0 - VoH, 5.0);
+ float Fc = pow(1.0 - VoH, 5.0);
A += (1.0 - Fc) * G_Vis;
B += Fc * G_Vis;
}
}
- A/=512.0;
- B/=512.0;
+ A /= 512.0;
+ B /= 512.0;
- int tofs = ((brdf_size-j-1)*brdf_size+i)*2;
- w[tofs+0]=CLAMP(A*255,0,255);
- w[tofs+1]=CLAMP(B*255,0,255);
+ int tofs = ((brdf_size - j - 1) * brdf_size + i) * 2;
+ w[tofs + 0] = CLAMP(A * 255, 0, 255);
+ w[tofs + 1] = CLAMP(B * 255, 0, 255);
}
}
-
//set up brdf texture
-
glGenTextures(1, &state.brdf_texture);
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,state.brdf_texture);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, brdf_size, brdf_size, 0, GL_RG, GL_UNSIGNED_BYTE,w.ptr());
+ glBindTexture(GL_TEXTURE_2D, state.brdf_texture);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, brdf_size, brdf_size, 0, GL_RG, GL_UNSIGNED_BYTE, w.ptr());
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glBindTexture(GL_TEXTURE_2D,0);
-
+ glBindTexture(GL_TEXTURE_2D, 0);
}
void RasterizerSceneGLES3::initialize() {
-
- render_pass=0;
+ render_pass = 0;
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);
+ storage->material_set_shader(default_material, default_shader);
default_shader_twosided = storage->shader_create(VS::SHADER_SPATIAL);
default_material_twosided = storage->material_create();
- storage->shader_set_code(default_shader_twosided,"render_mode cull_disabled;\n");
- storage->material_set_shader(default_material_twosided,default_shader_twosided);
-
+ storage->shader_set_code(default_shader_twosided, "render_mode cull_disabled;\n");
+ storage->material_set_shader(default_material_twosided, default_shader_twosided);
glGenBuffers(1, &state.scene_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, state.scene_ubo);
@@ -4781,61 +4434,53 @@ void RasterizerSceneGLES3::initialize() {
glBufferData(GL_UNIFORM_BUFFER, sizeof(State::EnvironmentRadianceUBO), &state.env_radiance_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.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;
{
//quad buffers
- glGenBuffers(1,&state.skybox_verts);
- glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
- glBufferData(GL_ARRAY_BUFFER,sizeof(Vector3)*8,NULL,GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glGenBuffers(1, &state.skybox_verts);
+ glBindBuffer(GL_ARRAY_BUFFER, state.skybox_verts);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * 8, NULL, GL_DYNAMIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
-
- glGenVertexArrays(1,&state.skybox_array);
+ glGenVertexArrays(1, &state.skybox_array);
glBindVertexArray(state.skybox_array);
- glBindBuffer(GL_ARRAY_BUFFER,state.skybox_verts);
- glVertexAttribPointer(VS::ARRAY_VERTEX,3,GL_FLOAT,GL_FALSE,sizeof(Vector3)*2,0);
+ glBindBuffer(GL_ARRAY_BUFFER, state.skybox_verts);
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, GL_FALSE, sizeof(Vector3) * 2, 0);
glEnableVertexAttribArray(VS::ARRAY_VERTEX);
- glVertexAttribPointer(VS::ARRAY_TEX_UV,3,GL_FLOAT,GL_FALSE,sizeof(Vector3)*2,((uint8_t*)NULL)+sizeof(Vector3));
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 3, GL_FLOAT, GL_FALSE, sizeof(Vector3) * 2, ((uint8_t *)NULL) + sizeof(Vector3));
glEnableVertexAttribArray(VS::ARRAY_TEX_UV);
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
}
render_list.init();
state.cube_to_dp_shader.init();
_generate_brdf();
- shadow_atlas_realloc_tolerance_msec=500;
-
-
+ shadow_atlas_realloc_tolerance_msec = 500;
-
-
- int max_shadow_cubemap_sampler_size=512;
+ int max_shadow_cubemap_sampler_size = 512;
int cube_size = max_shadow_cubemap_sampler_size;
glActiveTexture(GL_TEXTURE0);
- while(cube_size>=32) {
+ while (cube_size >= 32) {
ShadowCubeMap cube;
- cube.size=cube_size;
+ cube.size = cube_size;
- glGenTextures(1,&cube.cubemap);
- glBindTexture(GL_TEXTURE_CUBE_MAP,cube.cubemap);
+ glGenTextures(1, &cube.cubemap);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, cube.cubemap);
//gen cubemap first
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
- glTexImage2D(_cube_side_enum[i], 0, GL_DEPTH_COMPONENT24, cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+ glTexImage2D(_cube_side_enum[i], 0, GL_DEPTH_COMPONENT24, cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -4846,38 +4491,38 @@ void RasterizerSceneGLES3::initialize() {
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
//gen renderbuffers second, because it needs a complete cubemap
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glGenFramebuffers(1, &cube.fbo_id[i]);
glBindFramebuffer(GL_FRAMEBUFFER, cube.fbo_id[i]);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,_cube_side_enum[i], cube.cubemap, 0);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, _cube_side_enum[i], cube.cubemap, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
}
shadow_cubemaps.push_back(cube);
- cube_size>>=1;
+ cube_size >>= 1;
}
{
//directional light shadow
- directional_shadow.light_count=0;
- directional_shadow.size=nearest_power_of_2(GLOBAL_DEF("rendering/shadows/directional_shadow_size",2048));
- glGenFramebuffers(1,&directional_shadow.fbo);
- glBindFramebuffer(GL_FRAMEBUFFER,directional_shadow.fbo);
- glGenTextures(1,&directional_shadow.depth);
- glBindTexture(GL_TEXTURE_2D,directional_shadow.depth);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, directional_shadow.size, directional_shadow.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+ directional_shadow.light_count = 0;
+ directional_shadow.size = nearest_power_of_2(GLOBAL_DEF("rendering/shadows/directional_shadow_size", 2048));
+ glGenFramebuffers(1, &directional_shadow.fbo);
+ glBindFramebuffer(GL_FRAMEBUFFER, directional_shadow.fbo);
+ glGenTextures(1, &directional_shadow.depth);
+ glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, directional_shadow.size, directional_shadow.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
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_WRAP_R, GL_CLAMP_TO_EDGE);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, directional_shadow.depth, 0);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, directional_shadow.depth, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- if (status!=GL_FRAMEBUFFER_COMPLETE) {
+ if (status != GL_FRAMEBUFFER_COMPLETE) {
ERR_PRINT("Directional shadow framebuffer status invalid");
}
}
@@ -4886,24 +4531,23 @@ void RasterizerSceneGLES3::initialize() {
//spot and omni ubos
int max_ubo_size;
- glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE,&max_ubo_size);
- const int ubo_light_size=160;
- state.ubo_light_size=ubo_light_size;
- state.max_ubo_lights=MIN(RenderList::MAX_LIGHTS,max_ubo_size/ubo_light_size);
- print_line("max ubo light: "+itos(state.max_ubo_lights));
-
- state.spot_array_tmp = (uint8_t*)memalloc(ubo_light_size*state.max_ubo_lights);
- state.omni_array_tmp = (uint8_t*)memalloc(ubo_light_size*state.max_ubo_lights);
+ glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &max_ubo_size);
+ const int ubo_light_size = 160;
+ state.ubo_light_size = ubo_light_size;
+ state.max_ubo_lights = MIN(RenderList::MAX_LIGHTS, max_ubo_size / ubo_light_size);
+ print_line("max ubo light: " + itos(state.max_ubo_lights));
+ state.spot_array_tmp = (uint8_t *)memalloc(ubo_light_size * state.max_ubo_lights);
+ state.omni_array_tmp = (uint8_t *)memalloc(ubo_light_size * state.max_ubo_lights);
glGenBuffers(1, &state.spot_array_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, state.spot_array_ubo);
- glBufferData(GL_UNIFORM_BUFFER, ubo_light_size*state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
+ glBufferData(GL_UNIFORM_BUFFER, ubo_light_size * state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glGenBuffers(1, &state.omni_array_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, state.omni_array_ubo);
- glBufferData(GL_UNIFORM_BUFFER, ubo_light_size*state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
+ glBufferData(GL_UNIFORM_BUFFER, ubo_light_size * state.max_ubo_lights, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glGenBuffers(1, &state.directional_ubo);
@@ -4911,67 +4555,63 @@ void RasterizerSceneGLES3::initialize() {
glBufferData(GL_UNIFORM_BUFFER, sizeof(LightDataUBO), NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
- state.max_forward_lights_per_object=8;
+ state.max_forward_lights_per_object = 8;
+ state.scene_shader.add_custom_define("#define MAX_LIGHT_DATA_STRUCTS " + itos(state.max_ubo_lights) + "\n");
+ state.scene_shader.add_custom_define("#define MAX_FORWARD_LIGHTS " + itos(state.max_forward_lights_per_object) + "\n");
- state.scene_shader.add_custom_define("#define MAX_LIGHT_DATA_STRUCTS "+itos(state.max_ubo_lights)+"\n");
- state.scene_shader.add_custom_define("#define MAX_FORWARD_LIGHTS "+itos(state.max_forward_lights_per_object)+"\n");
+ state.max_ubo_reflections = MIN(RenderList::MAX_REFLECTIONS, max_ubo_size / sizeof(ReflectionProbeDataUBO));
+ print_line("max ubo reflections: " + itos(state.max_ubo_reflections) + " ubo size: " + itos(sizeof(ReflectionProbeDataUBO)));
- state.max_ubo_reflections=MIN(RenderList::MAX_REFLECTIONS,max_ubo_size/sizeof(ReflectionProbeDataUBO));
- print_line("max ubo reflections: "+itos(state.max_ubo_reflections)+" ubo size: "+itos(sizeof(ReflectionProbeDataUBO)));
-
- state.reflection_array_tmp = (uint8_t*)memalloc(sizeof(ReflectionProbeDataUBO)*state.max_ubo_reflections);
+ state.reflection_array_tmp = (uint8_t *)memalloc(sizeof(ReflectionProbeDataUBO) * state.max_ubo_reflections);
glGenBuffers(1, &state.reflection_array_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, state.reflection_array_ubo);
- glBufferData(GL_UNIFORM_BUFFER, sizeof(ReflectionProbeDataUBO)*state.max_ubo_reflections, NULL, GL_DYNAMIC_DRAW);
+ glBufferData(GL_UNIFORM_BUFFER, sizeof(ReflectionProbeDataUBO) * state.max_ubo_reflections, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
- state.scene_shader.add_custom_define("#define MAX_REFLECTION_DATA_STRUCTS "+itos(state.max_ubo_reflections)+"\n");
-
- state.max_skeleton_bones=MIN(2048,max_ubo_size/(12*sizeof(float)));
- state.scene_shader.add_custom_define("#define MAX_SKELETON_BONES "+itos(state.max_skeleton_bones)+"\n");
-
+ state.scene_shader.add_custom_define("#define MAX_REFLECTION_DATA_STRUCTS " + itos(state.max_ubo_reflections) + "\n");
+ state.max_skeleton_bones = MIN(2048, max_ubo_size / (12 * sizeof(float)));
+ state.scene_shader.add_custom_define("#define MAX_SKELETON_BONES " + itos(state.max_skeleton_bones) + "\n");
}
- GLOBAL_DEF("rendering/gles3/shadow_filter_mode",1);
- GlobalConfig::get_singleton()->set_custom_property_info("rendering/gles3/shadow_filter_mode",PropertyInfo(Variant::INT,"rendering/gles3/shadow_filter_mode",PROPERTY_HINT_ENUM,"Disabled,PCF5,PCF13"));
- shadow_filter_mode=SHADOW_FILTER_NEAREST;
+ GLOBAL_DEF("rendering/gles3/shadow_filter_mode", 1);
+ GlobalConfig::get_singleton()->set_custom_property_info("rendering/gles3/shadow_filter_mode", PropertyInfo(Variant::INT, "rendering/gles3/shadow_filter_mode", PROPERTY_HINT_ENUM, "Disabled,PCF5,PCF13"));
+ shadow_filter_mode = SHADOW_FILTER_NEAREST;
{ //reflection cubemaps
- int max_reflection_cubemap_sampler_size=512;
+ int max_reflection_cubemap_sampler_size = 512;
int cube_size = max_reflection_cubemap_sampler_size;
glActiveTexture(GL_TEXTURE0);
- bool use_float=true;
+ bool use_float = true;
- GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+ GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2;
GLenum format = GL_RGBA;
- GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+ GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV;
- while(cube_size>=32) {
+ while (cube_size >= 32) {
ReflectionCubeMap cube;
- cube.size=cube_size;
+ cube.size = cube_size;
- glGenTextures(1,&cube.depth);
- glBindTexture(GL_TEXTURE_2D,cube.depth);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+ glGenTextures(1, &cube.depth);
+ glBindTexture(GL_TEXTURE_2D, cube.depth);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, cube.size, cube.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
- glGenTextures(1,&cube.cubemap);
- glBindTexture(GL_TEXTURE_CUBE_MAP,cube.cubemap);
+ glGenTextures(1, &cube.cubemap);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, cube.cubemap);
//gen cubemap first
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
- glTexImage2D(_cube_side_enum[i], 0, internal_format, cube.size, cube.size, 0, format, type, NULL);
+ glTexImage2D(_cube_side_enum[i], 0, internal_format, cube.size, cube.size, 0, format, type, NULL);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -4982,41 +4622,37 @@ void RasterizerSceneGLES3::initialize() {
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
//gen renderbuffers second, because it needs a complete cubemap
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glGenFramebuffers(1, &cube.fbo_id[i]);
glBindFramebuffer(GL_FRAMEBUFFER, cube.fbo_id[i]);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,_cube_side_enum[i], cube.cubemap, 0);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, cube.depth, 0);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], cube.cubemap, 0);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, cube.depth, 0);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
}
reflection_cubemaps.push_back(cube);
- cube_size>>=1;
+ cube_size >>= 1;
}
}
{
-
- uint32_t immediate_buffer_size=GLOBAL_DEF("rendering/buffers/immediate_buffer_size_kb",2048);
+ uint32_t immediate_buffer_size = GLOBAL_DEF("rendering/buffers/immediate_buffer_size_kb", 2048);
glGenBuffers(1, &state.immediate_buffer);
glBindBuffer(GL_ARRAY_BUFFER, state.immediate_buffer);
- glBufferData(GL_ARRAY_BUFFER, immediate_buffer_size*1024, NULL, GL_DYNAMIC_DRAW);
+ glBufferData(GL_ARRAY_BUFFER, immediate_buffer_size * 1024, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
- glGenVertexArrays(1,&state.immediate_array);
-
-
-
+ glGenVertexArrays(1, &state.immediate_array);
}
#ifdef GLES_OVER_GL
-//"desktop" opengl needs this.
+ //"desktop" opengl needs this.
glEnable(GL_PROGRAM_POINT_SIZE);
#endif
@@ -5031,23 +4667,20 @@ void RasterizerSceneGLES3::initialize() {
state.exposure_shader.init();
state.tonemap_shader.init();
-
{
- GLOBAL_DEF("rendering/ssurf_scattering/quality",1);
- GlobalConfig::get_singleton()->set_custom_property_info("rendering/ssurf_scattering/quality",PropertyInfo(Variant::INT,"rendering/ssurf_scattering/quality",PROPERTY_HINT_ENUM,"Low,Medium,High"));
- GLOBAL_DEF("rendering/ssurf_scattering/max_size",1.0);
- GlobalConfig::get_singleton()->set_custom_property_info("rendering/ssurf_scattering/max_size",PropertyInfo(Variant::INT,"rendering/ssurf_scattering/max_size",PROPERTY_HINT_RANGE,"0.01,8,0.01"));
- GLOBAL_DEF("rendering/ssurf_scattering/follow_surface",false);
-
- GLOBAL_DEF("rendering/reflections/high_quality_vct_gi",true);
-
+ GLOBAL_DEF("rendering/ssurf_scattering/quality", 1);
+ GlobalConfig::get_singleton()->set_custom_property_info("rendering/ssurf_scattering/quality", PropertyInfo(Variant::INT, "rendering/ssurf_scattering/quality", PROPERTY_HINT_ENUM, "Low,Medium,High"));
+ GLOBAL_DEF("rendering/ssurf_scattering/max_size", 1.0);
+ GlobalConfig::get_singleton()->set_custom_property_info("rendering/ssurf_scattering/max_size", PropertyInfo(Variant::INT, "rendering/ssurf_scattering/max_size", PROPERTY_HINT_RANGE, "0.01,8,0.01"));
+ GLOBAL_DEF("rendering/ssurf_scattering/follow_surface", false);
+ GLOBAL_DEF("rendering/reflections/high_quality_vct_gi", true);
}
- exposure_shrink_size=243;
- int max_exposure_shrink_size=exposure_shrink_size;
+ exposure_shrink_size = 243;
+ int max_exposure_shrink_size = exposure_shrink_size;
- while(max_exposure_shrink_size>0) {
+ while (max_exposure_shrink_size > 0) {
RasterizerStorageGLES3::RenderTarget::Exposure e;
@@ -5056,41 +4689,33 @@ void RasterizerSceneGLES3::initialize() {
glGenTextures(1, &e.color);
glBindTexture(GL_TEXTURE_2D, e.color);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, max_exposure_shrink_size, max_exposure_shrink_size, 0, GL_RED, GL_FLOAT, NULL);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, e.color, 0);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, max_exposure_shrink_size, max_exposure_shrink_size, 0, GL_RED, GL_FLOAT, NULL);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, e.color, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
exposure_shrink.push_back(e);
- max_exposure_shrink_size/=3;
+ max_exposure_shrink_size /= 3;
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
-
-
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
}
-
}
void RasterizerSceneGLES3::iteration() {
- shadow_filter_mode=ShadowFilterMode(int(GlobalConfig::get_singleton()->get("rendering/gles3/shadow_filter_mode")));
- subsurface_scatter_follow_surface=GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/follow_surface");
- subsurface_scatter_quality=SubSurfaceScatterQuality(int(GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/quality")));
- subsurface_scatter_size=GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/max_size");
-
+ shadow_filter_mode = ShadowFilterMode(int(GlobalConfig::get_singleton()->get("rendering/gles3/shadow_filter_mode")));
+ subsurface_scatter_follow_surface = GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/follow_surface");
+ subsurface_scatter_quality = SubSurfaceScatterQuality(int(GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/quality")));
+ subsurface_scatter_size = GlobalConfig::get_singleton()->get("rendering/ssurf_scattering/max_size");
- state.scene_shader.set_conditional(SceneShaderGLES3::VCT_QUALITY_HIGH,GlobalConfig::get_singleton()->get("rendering/reflections/high_quality_vct_gi"));
+ state.scene_shader.set_conditional(SceneShaderGLES3::VCT_QUALITY_HIGH, GlobalConfig::get_singleton()->get("rendering/reflections/high_quality_vct_gi"));
}
-void RasterizerSceneGLES3::finalize(){
-
-
+void RasterizerSceneGLES3::finalize() {
}
-
-RasterizerSceneGLES3::RasterizerSceneGLES3()
-{
+RasterizerSceneGLES3::RasterizerSceneGLES3() {
}
diff --git a/drivers/gles3/rasterizer_scene_gles3.h b/drivers/gles3/rasterizer_scene_gles3.h
index b21ef8317..417a1d850 100644
--- a/drivers/gles3/rasterizer_scene_gles3.h
+++ b/drivers/gles3/rasterizer_scene_gles3.h
@@ -29,29 +29,27 @@
#ifndef RASTERIZERSCENEGLES3_H
#define RASTERIZERSCENEGLES3_H
-#include "rasterizer_storage_gles3.h"
-#include "drivers/gles3/shaders/scene.glsl.h"
#include "drivers/gles3/shaders/cube_to_dp.glsl.h"
+#include "drivers/gles3/shaders/effect_blur.glsl.h"
+#include "drivers/gles3/shaders/exposure.glsl.h"
#include "drivers/gles3/shaders/resolve.glsl.h"
+#include "drivers/gles3/shaders/scene.glsl.h"
#include "drivers/gles3/shaders/screen_space_reflection.glsl.h"
-#include "drivers/gles3/shaders/effect_blur.glsl.h"
-#include "drivers/gles3/shaders/subsurf_scattering.glsl.h"
-#include "drivers/gles3/shaders/ssao_minify.glsl.h"
#include "drivers/gles3/shaders/ssao.glsl.h"
#include "drivers/gles3/shaders/ssao_blur.glsl.h"
-#include "drivers/gles3/shaders/exposure.glsl.h"
+#include "drivers/gles3/shaders/ssao_minify.glsl.h"
+#include "drivers/gles3/shaders/subsurf_scattering.glsl.h"
#include "drivers/gles3/shaders/tonemap.glsl.h"
+#include "rasterizer_storage_gles3.h"
class RasterizerSceneGLES3 : public RasterizerScene {
public:
-
enum ShadowFilterMode {
SHADOW_FILTER_NEAREST,
SHADOW_FILTER_PCF5,
SHADOW_FILTER_PCF13,
};
-
ShadowFilterMode shadow_filter_mode;
uint64_t shadow_atlas_realloc_tolerance_msec;
@@ -83,8 +81,6 @@ public:
struct State {
-
-
bool texscreen_copied;
int current_blend_mode;
float current_line_width;
@@ -104,7 +100,6 @@ public:
ExposureShaderGLES3 exposure_shader;
TonemapShaderGLES3 tonemap_shader;
-
struct SceneDataUBO {
float projection_matrix[16];
@@ -167,7 +162,6 @@ public:
bool used_contact_shadows;
-
int spot_light_count;
int omni_light_count;
int directional_light_count;
@@ -178,15 +172,14 @@ public:
} state;
-
/* SHADOW ATLAS API */
struct ShadowAtlas : public RID_Data {
enum {
- QUADRANT_SHIFT=27,
- SHADOW_INDEX_MASK=(1<<QUADRANT_SHIFT)-1,
- SHADOW_INVALID=0xFFFFFFFF
+ QUADRANT_SHIFT = 27,
+ SHADOW_INDEX_MASK = (1 << QUADRANT_SHIFT) - 1,
+ SHADOW_INVALID = 0xFFFFFFFF
};
struct Quadrant {
@@ -199,15 +192,15 @@ public:
uint64_t alloc_tick;
Shadow() {
- version=0;
- alloc_tick=0;
+ version = 0;
+ alloc_tick = 0;
}
};
Vector<Shadow> shadows;
Quadrant() {
- subdivision=0; //not in use
+ subdivision = 0; //not in use
}
} quadrants[4];
@@ -220,7 +213,7 @@ public:
GLuint fbo;
GLuint depth;
- Map<RID,uint32_t> shadow_owners;
+ Map<RID, uint32_t> shadow_owners;
};
struct ShadowCubeMap {
@@ -235,10 +228,10 @@ public:
RID_Owner<ShadowAtlas> shadow_atlas_owner;
RID shadow_atlas_create();
- void shadow_atlas_set_size(RID p_atlas,int p_size);
- void shadow_atlas_set_quadrant_subdivision(RID p_atlas,int p_quadrant,int p_subdivision);
+ void shadow_atlas_set_size(RID p_atlas, int p_size);
+ void shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision);
bool _shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow);
- bool shadow_atlas_update_light(RID p_atlas,RID p_light_intance,float p_coverage,uint64_t p_light_version);
+ bool shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version);
struct DirectionalShadow {
GLuint fbo;
@@ -272,8 +265,8 @@ public:
mutable RID_Owner<ReflectionAtlas> reflection_atlas_owner;
virtual RID reflection_atlas_create();
- virtual void reflection_atlas_set_size(RID p_ref_atlas,int p_size);
- virtual void reflection_atlas_set_subdivision(RID p_ref_atlas,int p_subdiv);
+ virtual void reflection_atlas_set_size(RID p_ref_atlas, int p_size);
+ virtual void reflection_atlas_set_subdivision(RID p_ref_atlas, int p_subdiv);
/* REFLECTION CUBEMAPS */
@@ -300,8 +293,6 @@ public:
int render_step;
-
-
uint64_t last_pass;
int reflection_index;
@@ -319,20 +310,16 @@ public:
//notes: for ambientblend, use distance to edge to blend between already existing global environment
};
-
mutable RID_Owner<ReflectionProbeInstance> reflection_probe_instance_owner;
virtual RID reflection_probe_instance_create(RID p_probe);
- virtual void reflection_probe_instance_set_transform(RID p_instance,const Transform& p_transform);
+ virtual void reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform);
virtual void reflection_probe_release_atlas_index(RID p_instance);
virtual bool reflection_probe_instance_needs_redraw(RID p_instance);
virtual bool reflection_probe_instance_has_reflection(RID p_instance);
virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas);
virtual bool reflection_probe_instance_postprocess_step(RID p_instance);
-
-
-
/* ENVIRONMENT API */
struct Environment : public RID_Data {
@@ -360,7 +347,6 @@ public:
bool ssr_smooth;
bool ssr_roughness;
-
bool ssao_enabled;
float ssao_intensity;
float ssao_radius;
@@ -403,62 +389,61 @@ public:
VS::EnvironmentDOFBlurQuality dof_blur_near_quality;
Environment() {
- bg_mode=VS::ENV_BG_CLEAR_COLOR;
- skybox_scale=1.0;
- bg_energy=1.0;
- skybox_ambient=0;
- ambient_energy=1.0;
- ambient_skybox_contribution=0.0;
- canvas_max_layer=0;
-
- ssr_enabled=false;
- ssr_max_steps=64;
- ssr_accel=0.04;
- ssr_fade=2.0;
- ssr_depth_tolerance=0.2;
- ssr_smooth=true;
- ssr_roughness=true;
+ bg_mode = VS::ENV_BG_CLEAR_COLOR;
+ skybox_scale = 1.0;
+ bg_energy = 1.0;
+ skybox_ambient = 0;
+ ambient_energy = 1.0;
+ ambient_skybox_contribution = 0.0;
+ canvas_max_layer = 0;
- ssao_enabled=false;
- ssao_intensity=1.0;
- ssao_radius=1.0;
- ssao_intensity2=1.0;
- ssao_radius2=0.0;
- ssao_bias=0.01;
- ssao_light_affect=0;
- ssao_filter=true;
+ ssr_enabled = false;
+ ssr_max_steps = 64;
+ ssr_accel = 0.04;
+ ssr_fade = 2.0;
+ ssr_depth_tolerance = 0.2;
+ ssr_smooth = true;
+ ssr_roughness = true;
- tone_mapper=VS::ENV_TONE_MAPPER_LINEAR;
- tone_mapper_exposure=1.0;
- tone_mapper_exposure_white=1.0;
- auto_exposure=false;
- auto_exposure_speed=0.5;
- auto_exposure_min=0.05;
- auto_exposure_max=8;
- auto_exposure_grey=0.4;
+ ssao_enabled = false;
+ ssao_intensity = 1.0;
+ ssao_radius = 1.0;
+ ssao_intensity2 = 1.0;
+ ssao_radius2 = 0.0;
+ ssao_bias = 0.01;
+ ssao_light_affect = 0;
+ ssao_filter = true;
- glow_enabled=false;
- glow_levels=(1<<2)|(1<<4);
- glow_intensity=0.8;
- glow_strength=1.0;
- glow_bloom=0.0;
- glow_blend_mode=VS::GLOW_BLEND_MODE_SOFTLIGHT;
- glow_hdr_bleed_treshold=1.0;
- glow_hdr_bleed_scale=2.0;
- glow_bicubic_upscale=false;
+ tone_mapper = VS::ENV_TONE_MAPPER_LINEAR;
+ tone_mapper_exposure = 1.0;
+ tone_mapper_exposure_white = 1.0;
+ auto_exposure = false;
+ auto_exposure_speed = 0.5;
+ auto_exposure_min = 0.05;
+ auto_exposure_max = 8;
+ auto_exposure_grey = 0.4;
- dof_blur_far_enabled=false;
- dof_blur_far_distance=10;
- dof_blur_far_transition=5;
- dof_blur_far_amount=0.1;
- dof_blur_far_quality=VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
+ glow_enabled = false;
+ glow_levels = (1 << 2) | (1 << 4);
+ glow_intensity = 0.8;
+ glow_strength = 1.0;
+ glow_bloom = 0.0;
+ glow_blend_mode = VS::GLOW_BLEND_MODE_SOFTLIGHT;
+ glow_hdr_bleed_treshold = 1.0;
+ glow_hdr_bleed_scale = 2.0;
+ glow_bicubic_upscale = false;
- dof_blur_near_enabled=false;
- dof_blur_near_distance=2;
- dof_blur_near_transition=1;
- dof_blur_near_amount=0.1;
- dof_blur_near_quality=VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
+ dof_blur_far_enabled = false;
+ dof_blur_far_distance = 10;
+ dof_blur_far_transition = 5;
+ dof_blur_far_amount = 0.1;
+ dof_blur_far_quality = VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
+ dof_blur_near_enabled = false;
+ dof_blur_near_distance = 2;
+ dof_blur_near_transition = 1;
+ dof_blur_near_amount = 0.1;
+ dof_blur_near_quality = VS::ENV_DOF_BLUR_QUALITY_MEDIUM;
}
};
@@ -466,27 +451,25 @@ public:
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);
- virtual void environment_set_skybox_scale(RID p_env,float p_scale);
- virtual void environment_set_bg_color(RID p_env,const Color& p_color);
- virtual void environment_set_bg_energy(RID p_env,float p_energy);
- 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,float p_skybox_contribution=0.0);
-
- virtual void environment_set_dof_blur_near(RID p_env,bool p_enable,float p_distance,float p_transition,float p_far_amount,VS::EnvironmentDOFBlurQuality p_quality);
- virtual void environment_set_dof_blur_far(RID p_env,bool p_enable,float p_distance,float p_transition,float p_far_amount,VS::EnvironmentDOFBlurQuality p_quality);
- virtual void environment_set_glow(RID p_env,bool p_enable,int p_level_flags,float p_intensity,float p_strength,float p_bloom_treshold,VS::EnvironmentGlowBlendMode p_blend_mode,float p_hdr_bleed_treshold,float p_hdr_bleed_scale,bool p_bicubic_upscale);
- 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_background(RID p_env, VS::EnvironmentBG p_bg);
+ virtual void environment_set_skybox(RID p_env, RID p_skybox);
+ virtual void environment_set_skybox_scale(RID p_env, float p_scale);
+ virtual void environment_set_bg_color(RID p_env, const Color &p_color);
+ virtual void environment_set_bg_energy(RID p_env, float p_energy);
+ 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, float p_skybox_contribution = 0.0);
- virtual void environment_set_ssr(RID p_env,bool p_enable, int p_max_steps,float p_accel,float p_fade,float p_depth_tolerance,bool p_smooth,bool p_roughness);
- virtual void environment_set_ssao(RID p_env,bool p_enable, float p_radius, float p_radius2, float p_intensity2, float p_intensity, float p_bias, float p_light_affect,const Color &p_color,bool p_blur);
+ virtual void environment_set_dof_blur_near(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality);
+ virtual void environment_set_dof_blur_far(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality);
+ virtual void environment_set_glow(RID p_env, bool p_enable, int p_level_flags, float p_intensity, float p_strength, float p_bloom_treshold, VS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_treshold, float p_hdr_bleed_scale, bool p_bicubic_upscale);
+ 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_ssr(RID p_env, bool p_enable, int p_max_steps, float p_accel, float p_fade, float p_depth_tolerance, bool p_smooth, bool p_roughness);
+ virtual void environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_radius2, float p_intensity2, float p_intensity, float p_bias, float p_light_affect, const Color &p_color, bool p_blur);
- virtual void environment_set_tonemap(RID p_env,VS::EnvironmentToneMapper p_tone_mapper,float p_exposure,float p_white,bool p_auto_exposure,float p_min_luminance,float p_max_luminance,float p_auto_exp_speed,float p_auto_exp_scale);
-
- virtual void environment_set_adjustment(RID p_env,bool p_enable,float p_brightness,float p_contrast,float p_saturation,RID p_ramp);
+ virtual void environment_set_tonemap(RID p_env, VS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white, bool p_auto_exposure, float p_min_luminance, float p_max_luminance, float p_auto_exp_speed, float p_auto_exp_scale);
+ virtual void environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, RID p_ramp);
/* LIGHT INSTANCE */
@@ -503,7 +486,6 @@ public:
float shadow_matrix3[16];
float shadow_matrix4[16];
float shadow_split_offsets[4];
-
};
struct LightInstance : public RID_Data {
@@ -516,8 +498,6 @@ public:
float split;
};
-
-
ShadowTransform shadow_transform[4];
RID self;
@@ -542,18 +522,16 @@ public:
Rect2 directional_rect;
-
Set<RID> shadow_atlases; //shadow atlases where this light is registered
- LightInstance() { }
-
+ LightInstance() {}
};
mutable RID_Owner<LightInstance> light_instance_owner;
virtual RID light_instance_create(RID p_light);
- virtual void light_instance_set_transform(RID p_light_instance,const Transform& p_transform);
- virtual void light_instance_set_shadow_transform(RID p_light_instance,const CameraMatrix& p_projection,const Transform& p_transform,float p_far,float p_split,int p_pass);
+ virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);
+ virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass);
virtual void light_instance_mark_visible(RID p_light_instance);
/* REFLECTION INSTANCE */
@@ -566,42 +544,42 @@ public:
Vector3 bounds;
Transform transform_to_data;
- GIProbeInstance() { probe=NULL; tex_cache=0; }
+ GIProbeInstance() {
+ probe = NULL;
+ tex_cache = 0;
+ }
};
-
-
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_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);
+ 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);
/* RENDER LIST */
struct RenderList {
enum {
- DEFAULT_MAX_ELEMENTS=65536,
- SORT_FLAG_SKELETON=1,
- SORT_FLAG_INSTANCING=2,
- MAX_DIRECTIONAL_LIGHTS=16,
- MAX_LIGHTS=4096,
- MAX_REFLECTIONS=1024,
+ DEFAULT_MAX_ELEMENTS = 65536,
+ SORT_FLAG_SKELETON = 1,
+ SORT_FLAG_INSTANCING = 2,
+ MAX_DIRECTIONAL_LIGHTS = 16,
+ MAX_LIGHTS = 4096,
+ MAX_REFLECTIONS = 1024,
-
- SORT_KEY_DEPTH_LAYER_SHIFT=60,
- SORT_KEY_UNSHADED_FLAG=uint64_t(1)<<59,
- SORT_KEY_NO_DIRECTIONAL_FLAG=uint64_t(1)<<58,
- SORT_KEY_GI_PROBES_FLAG=uint64_t(1)<<57,
- SORT_KEY_SHADING_SHIFT=57,
- SORT_KEY_SHADING_MASK=7,
- SORT_KEY_MATERIAL_INDEX_SHIFT=40,
- SORT_KEY_GEOMETRY_INDEX_SHIFT=20,
- SORT_KEY_GEOMETRY_TYPE_SHIFT=15,
- SORT_KEY_SKELETON_FLAG=2,
- SORT_KEY_MIRROR_FLAG=1
+ SORT_KEY_DEPTH_LAYER_SHIFT = 60,
+ SORT_KEY_UNSHADED_FLAG = uint64_t(1) << 59,
+ SORT_KEY_NO_DIRECTIONAL_FLAG = uint64_t(1) << 58,
+ SORT_KEY_GI_PROBES_FLAG = uint64_t(1) << 57,
+ SORT_KEY_SHADING_SHIFT = 57,
+ SORT_KEY_SHADING_MASK = 7,
+ SORT_KEY_MATERIAL_INDEX_SHIFT = 40,
+ SORT_KEY_GEOMETRY_INDEX_SHIFT = 20,
+ SORT_KEY_GEOMETRY_TYPE_SHIFT = 15,
+ SORT_KEY_SKELETON_FLAG = 2,
+ SORT_KEY_MIRROR_FLAG = 1
};
@@ -614,74 +592,70 @@ public:
RasterizerStorageGLES3::Material *material;
RasterizerStorageGLES3::GeometryOwner *owner;
uint64_t sort_key;
-
};
-
Element *_elements;
Element **elements;
int element_count;
int alpha_element_count;
-
void clear() {
- element_count=0;
- alpha_element_count=0;
+ 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 {
+ _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;
+ SortArray<Element *, SortByKey> sorter;
if (p_alpha) {
- sorter.sort(&elements[max_elements-alpha_element_count],alpha_element_count);
+ sorter.sort(&elements[max_elements - alpha_element_count], alpha_element_count);
} else {
- sorter.sort(elements,element_count);
+ sorter.sort(elements, element_count);
}
}
struct SortByDepth {
- _FORCE_INLINE_ bool operator()(const Element* A, const Element* B ) const {
+ _FORCE_INLINE_ bool operator()(const Element *A, const Element *B) const {
return A->instance->depth > B->instance->depth;
}
};
void sort_by_depth(bool p_alpha) {
- SortArray<Element*,SortByDepth> sorter;
+ SortArray<Element *, SortByDepth> sorter;
if (p_alpha) {
- sorter.sort(&elements[max_elements-alpha_element_count],alpha_element_count);
+ sorter.sort(&elements[max_elements - alpha_element_count], alpha_element_count);
} else {
- sorter.sort(elements,element_count);
+ sorter.sort(elements, element_count);
}
}
+ _FORCE_INLINE_ Element *add_element() {
- _FORCE_INLINE_ Element* add_element() {
-
- if (element_count+alpha_element_count>=max_elements)
+ if (element_count + alpha_element_count >= max_elements)
return NULL;
- elements[element_count]=&_elements[element_count];
+ elements[element_count] = &_elements[element_count];
return elements[element_count++];
}
- _FORCE_INLINE_ Element* add_alpha_element() {
+ _FORCE_INLINE_ Element *add_alpha_element() {
- if (element_count+alpha_element_count>=max_elements)
+ if (element_count + alpha_element_count >= max_elements)
return NULL;
- int idx = max_elements-alpha_element_count-1;
- elements[idx]=&_elements[idx];
+ int idx = max_elements - alpha_element_count - 1;
+ elements[idx] = &_elements[idx];
alpha_element_count++;
return elements[idx];
}
@@ -689,18 +663,16 @@ public:
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
-
+ 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;
+ max_elements = DEFAULT_MAX_ELEMENTS;
}
~RenderList() {
@@ -709,45 +681,41 @@ public:
}
};
-
LightInstance *directional_light;
LightInstance *directional_lights[RenderList::MAX_DIRECTIONAL_LIGHTS];
-
-
RenderList render_list;
- _FORCE_INLINE_ void _set_cull(bool p_front,bool p_reverse_cull);
+ _FORCE_INLINE_ void _set_cull(bool p_front, bool p_reverse_cull);
- _FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES3::Material* p_material,bool p_alpha_pass);
- _FORCE_INLINE_ void _setup_transform(InstanceBase *p_instance,const Transform& p_view_transform,const CameraMatrix& p_projection);
+ _FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES3::Material *p_material, bool p_alpha_pass);
+ _FORCE_INLINE_ void _setup_transform(InstanceBase *p_instance, const Transform &p_view_transform, const CameraMatrix &p_projection);
_FORCE_INLINE_ void _setup_geometry(RenderList::Element *e);
_FORCE_INLINE_ void _render_geometry(RenderList::Element *e);
- _FORCE_INLINE_ void _setup_light(RenderList::Element *e,const Transform& p_view_transform);
-
- void _render_list(RenderList::Element **p_elements, int p_element_count, const Transform& p_view_transform, const CameraMatrix& p_projection, GLuint p_base_env, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow, bool p_directional_add, bool p_directional_shadows);
+ _FORCE_INLINE_ void _setup_light(RenderList::Element *e, const Transform &p_view_transform);
+ void _render_list(RenderList::Element **p_elements, int p_element_count, const Transform &p_view_transform, const CameraMatrix &p_projection, GLuint p_base_env, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow, bool p_directional_add, bool p_directional_shadows);
- _FORCE_INLINE_ void _add_geometry( RasterizerStorageGLES3::Geometry* p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner,int p_material,bool p_shadow);
+ _FORCE_INLINE_ void _add_geometry(RasterizerStorageGLES3::Geometry *p_geometry, InstanceBase *p_instance, RasterizerStorageGLES3::GeometryOwner *p_owner, int p_material, bool p_shadow);
- void _draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox, const CameraMatrix& p_projection, const Transform& p_transform, bool p_vflip, float p_scale);
+ void _draw_skybox(RasterizerStorageGLES3::SkyBox *p_skybox, const CameraMatrix &p_projection, const Transform &p_transform, bool p_vflip, float p_scale);
- void _setup_environment(Environment *env, const CameraMatrix &p_cam_projection, const Transform& p_cam_transform);
+ void _setup_environment(Environment *env, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform);
void _setup_directional_light(int p_index, const Transform &p_camera_inverse_transformm, bool p_use_shadows);
- void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix& p_camera_projection, RID p_shadow_atlas);
- void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform& p_camera_inverse_transform, const CameraMatrix& p_camera_projection, RID p_reflection_atlas, Environment *p_env);
+ void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_shadow_atlas);
+ void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, const CameraMatrix &p_camera_projection, RID p_reflection_atlas, Environment *p_env);
void _copy_screen();
void _copy_to_front_buffer(Environment *env);
void _copy_texture_to_front_buffer(GLuint p_texture); //used for debug
- void _fill_render_list(InstanceBase** p_cull_result,int p_cull_count,bool p_shadow);
+ void _fill_render_list(InstanceBase **p_cull_result, int p_cull_count, bool p_shadow);
void _render_mrts(Environment *env, const CameraMatrix &p_cam_projection);
void _post_process(Environment *env, const CameraMatrix &p_cam_projection);
- virtual void render_scene(const Transform& p_cam_transform,const 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_reflection_probe_cull_result,int p_reflection_probe_cull_count,RID p_environment,RID p_shadow_atlas,RID p_reflection_atlas,RID p_reflection_probe,int p_reflection_probe_pass);
- virtual void render_shadow(RID p_light,RID p_shadow_atlas,int p_pass,InstanceBase** p_cull_result,int p_cull_count);
+ virtual void render_scene(const Transform &p_cam_transform, const 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_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID p_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
+ virtual void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count);
virtual bool free(RID p_rid);
void _generate_brdf();
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp
index 4fea28ddb..ed4be1cb3 100644
--- a/drivers/gles3/rasterizer_storage_gles3.cpp
+++ b/drivers/gles3/rasterizer_storage_gles3.cpp
@@ -27,32 +27,30 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "rasterizer_storage_gles3.h"
+#include "global_config.h"
#include "rasterizer_canvas_gles3.h"
#include "rasterizer_scene_gles3.h"
-#include "global_config.h"
/* TEXTURE API */
-#define _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
-#define _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01
-#define _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
-#define _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
-
-#define _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT 0x8A54
-#define _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT 0x8A55
-#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT 0x8A56
-#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT 0x8A57
+#define _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
+#define _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01
+#define _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
+#define _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
+#define _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT 0x8A54
+#define _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT 0x8A55
+#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT 0x8A56
+#define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT 0x8A57
#define _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
#define _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
#define _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
-#define _EXT_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70
-#define _EXT_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71
-#define _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72
-#define _EXT_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73
-
+#define _EXT_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70
+#define _EXT_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71
+#define _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72
+#define _EXT_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73
#define _EXT_COMPRESSED_RED_RGTC1_EXT 0x8DBB
#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
@@ -62,33 +60,27 @@
#define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
#define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
-#define _EXT_ETC1_RGB8_OES 0x8D64
-
-
-
-#define _EXT_SLUMINANCE_NV 0x8C46
-#define _EXT_SLUMINANCE_ALPHA_NV 0x8C44
-#define _EXT_SRGB8_NV 0x8C41
-#define _EXT_SLUMINANCE8_NV 0x8C47
-#define _EXT_SLUMINANCE8_ALPHA8_NV 0x8C45
+#define _EXT_ETC1_RGB8_OES 0x8D64
+#define _EXT_SLUMINANCE_NV 0x8C46
+#define _EXT_SLUMINANCE_ALPHA_NV 0x8C44
+#define _EXT_SRGB8_NV 0x8C41
+#define _EXT_SLUMINANCE8_NV 0x8C47
+#define _EXT_SLUMINANCE8_ALPHA8_NV 0x8C45
-#define _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV 0x8C4C
-#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV 0x8C4D
-#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV 0x8C4E
-#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV 0x8C4F
+#define _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV 0x8C4C
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV 0x8C4D
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV 0x8C4E
+#define _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV 0x8C4F
+#define _EXT_ATC_RGB_AMD 0x8C92
+#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93
+#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE
+#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
-#define _EXT_ATC_RGB_AMD 0x8C92
-#define _EXT_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93
-#define _EXT_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE
-
-
-#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
-
-#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
-#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
+#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
#define _EXT_COMPRESSED_R11_EAC 0x9270
#define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271
@@ -108,235 +100,221 @@
GLuint RasterizerStorageGLES3::system_fbo = 0;
-Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags,GLenum& r_gl_format,GLenum& r_gl_internal_format,GLenum &r_gl_type,bool &r_compressed,bool &srgb) {
-
+Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool &srgb) {
- r_compressed=false;
- r_gl_format=0;
- Image image=p_image;
- srgb=false;
+ r_compressed = false;
+ r_gl_format = 0;
+ Image image = p_image;
+ srgb = false;
- bool need_decompress=false;
+ bool need_decompress = false;
- switch(p_format) {
+ switch (p_format) {
case Image::FORMAT_L8: {
#ifdef GLES_OVER_GL
- r_gl_internal_format=GL_R8;
- r_gl_format=GL_RED;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_R8;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_UNSIGNED_BYTE;
#else
- r_gl_internal_format=GL_LUMINANCE;
- r_gl_format=GL_LUMINANCE;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_LUMINANCE;
+ r_gl_format = GL_LUMINANCE;
+ r_gl_type = GL_UNSIGNED_BYTE;
#endif
} break;
case Image::FORMAT_LA8: {
#ifdef GLES_OVER_GL
- r_gl_internal_format=GL_RG8;
- r_gl_format=GL_RG;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_RG8;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_UNSIGNED_BYTE;
#else
- r_gl_internal_format=GL_LUMINANCE_ALPHA;
- r_gl_format=GL_LUMINANCE_ALPHA;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_LUMINANCE_ALPHA;
+ r_gl_format = GL_LUMINANCE_ALPHA;
+ r_gl_type = GL_UNSIGNED_BYTE;
#endif
} break;
case Image::FORMAT_R8: {
- r_gl_internal_format=GL_R8;
- r_gl_format=GL_RED;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_R8;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_UNSIGNED_BYTE;
} break;
case Image::FORMAT_RG8: {
- r_gl_internal_format=GL_RG8;
- r_gl_format=GL_RG;
- r_gl_type=GL_UNSIGNED_BYTE;
+ r_gl_internal_format = GL_RG8;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_UNSIGNED_BYTE;
} break;
case Image::FORMAT_RGB8: {
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8:GL_RGB8;
- r_gl_format=GL_RGB;
- r_gl_type=GL_UNSIGNED_BYTE;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8 : GL_RGB8;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ srgb = true;
} break;
case Image::FORMAT_RGBA8: {
- r_gl_format=GL_RGBA;
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8;
- r_gl_type=GL_UNSIGNED_BYTE;
- srgb=true;
+ r_gl_format = GL_RGBA;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8_ALPHA8 : GL_RGBA8;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ srgb = true;
} break;
case Image::FORMAT_RGB565: {
#ifndef GLES_OVER_GL
- r_gl_internal_format=GL_RGB565;
+ r_gl_internal_format = GL_RGB565;
#else
-//#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-)
- r_gl_internal_format=GL_RGB5;
+ //#warning TODO: Convert tod 555 if 565 is not supported (GLES3.3-)
+ r_gl_internal_format = GL_RGB5;
#endif
//r_gl_internal_format=GL_RGB565;
- r_gl_format=GL_RGB;
- r_gl_type=GL_UNSIGNED_SHORT_5_6_5;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_UNSIGNED_SHORT_5_6_5;
} break;
case Image::FORMAT_RGBA4444: {
- r_gl_internal_format=GL_RGBA4;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_SHORT_4_4_4_4;
+ r_gl_internal_format = GL_RGBA4;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_SHORT_4_4_4_4;
} break;
case Image::FORMAT_RGBA5551: {
- r_gl_internal_format=GL_RGB5_A1;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_SHORT_5_5_5_1;
-
+ r_gl_internal_format = GL_RGB5_A1;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_SHORT_5_5_5_1;
} break;
case Image::FORMAT_RF: {
-
- r_gl_internal_format=GL_R32F;
- r_gl_format=GL_RED;
- r_gl_type=GL_FLOAT;
+ r_gl_internal_format = GL_R32F;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_FLOAT;
} break;
case Image::FORMAT_RGF: {
- r_gl_internal_format=GL_RG32F;
- r_gl_format=GL_RG;
- r_gl_type=GL_FLOAT;
+ r_gl_internal_format = GL_RG32F;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_FLOAT;
} break;
case Image::FORMAT_RGBF: {
- r_gl_internal_format=GL_RGB32F;
- r_gl_format=GL_RGB;
- r_gl_type=GL_FLOAT;
+ r_gl_internal_format = GL_RGB32F;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_FLOAT;
} break;
case Image::FORMAT_RGBAF: {
- r_gl_internal_format=GL_RGBA32F;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_FLOAT;
+ r_gl_internal_format = GL_RGBA32F;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_FLOAT;
} break;
case Image::FORMAT_RH: {
- r_gl_internal_format=GL_R32F;
- r_gl_format=GL_RED;
- r_gl_type=GL_HALF_FLOAT;
+ r_gl_internal_format = GL_R32F;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_HALF_FLOAT;
} break;
case Image::FORMAT_RGH: {
- r_gl_internal_format=GL_RG32F;
- r_gl_format=GL_RG;
- r_gl_type=GL_HALF_FLOAT;
+ r_gl_internal_format = GL_RG32F;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_HALF_FLOAT;
} break;
case Image::FORMAT_RGBH: {
- r_gl_internal_format=GL_RGB32F;
- r_gl_format=GL_RGB;
- r_gl_type=GL_HALF_FLOAT;
+ r_gl_internal_format = GL_RGB32F;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_HALF_FLOAT;
} break;
case Image::FORMAT_RGBAH: {
- r_gl_internal_format=GL_RGBA32F;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_HALF_FLOAT;
+ r_gl_internal_format = GL_RGBA32F;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_HALF_FLOAT;
} break;
case Image::FORMAT_DXT1: {
if (config.s3tc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_S3TC_DXT1_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_S3TC_DXT1_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
} break;
case Image::FORMAT_DXT3: {
-
if (config.s3tc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
} break;
case Image::FORMAT_DXT5: {
if (config.s3tc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV:_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV : _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
} break;
case Image::FORMAT_ATI1: {
if (config.latc_supported) {
-
- r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_LATC1_EXT;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = _EXT_COMPRESSED_LUMINANCE_LATC1_EXT;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
-
} break;
case Image::FORMAT_ATI2: {
if (config.latc_supported) {
-
- r_gl_internal_format=_EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
@@ -344,93 +322,86 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima
if (config.bptc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:_EXT_COMPRESSED_RGBA_BPTC_UNORM;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM : _EXT_COMPRESSED_RGBA_BPTC_UNORM;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_BPTC_RGBF: {
if (config.bptc_supported) {
-
- r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
- r_gl_format=GL_RGB;
- r_gl_type=GL_FLOAT;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_FLOAT;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_BPTC_RGBFU: {
if (config.bptc_supported) {
-
- r_gl_internal_format=_EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
- r_gl_format=GL_RGB;
- r_gl_type=GL_FLOAT;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_FLOAT;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_PVRTC2: {
if (config.pvrtc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT : _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_PVRTC2A: {
if (config.pvrtc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT : _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
} break;
case Image::FORMAT_PVRTC4: {
if (config.pvrtc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT : _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
@@ -438,32 +409,30 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima
if (config.pvrtc_supported) {
-
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT:_EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT : _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
-
} break;
case Image::FORMAT_ETC: {
if (config.etc_supported) {
- r_gl_internal_format=_EXT_ETC1_RGB8_OES;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_ETC1_RGB8_OES;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
@@ -471,102 +440,99 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima
if (config.etc2_supported) {
- r_gl_internal_format=_EXT_COMPRESSED_R11_EAC;
- r_gl_format=GL_RED;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_R11_EAC;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_R11S: {
if (config.etc2_supported) {
- r_gl_internal_format=_EXT_COMPRESSED_SIGNED_R11_EAC;
- r_gl_format=GL_RED;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_SIGNED_R11_EAC;
+ r_gl_format = GL_RED;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_RG11: {
if (config.etc2_supported) {
- r_gl_internal_format=_EXT_COMPRESSED_RG11_EAC;
- r_gl_format=GL_RG;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_RG11_EAC;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_RG11S: {
if (config.etc2_supported) {
- r_gl_internal_format=_EXT_COMPRESSED_SIGNED_RG11_EAC;
- r_gl_format=GL_RG;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
+ r_gl_internal_format = _EXT_COMPRESSED_SIGNED_RG11_EAC;
+ r_gl_format = GL_RG;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_RGB8: {
if (config.etc2_supported) {
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ETC2:_EXT_COMPRESSED_RGB8_ETC2;
- r_gl_format=GL_RGB;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
-
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_ETC2 : _EXT_COMPRESSED_RGB8_ETC2;
+ r_gl_format = GL_RGB;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_RGBA8: {
if (config.etc2_supported) {
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:_EXT_COMPRESSED_RGBA8_ETC2_EAC;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
-
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : _EXT_COMPRESSED_RGBA8_ETC2_EAC;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
case Image::FORMAT_ETC2_RGB8A1: {
if (config.etc2_supported) {
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?_EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:_EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
- r_gl_format=GL_RGBA;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=true;
- srgb=true;
-
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? _EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+ r_gl_format = GL_RGBA;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = true;
+ srgb = true;
} else {
- need_decompress=true;
+ need_decompress = true;
}
} break;
default: {
@@ -579,26 +545,23 @@ Image RasterizerStorageGLES3::_get_gl_image_and_format(const Image& p_image, Ima
if (!image.empty()) {
image.decompress();
- ERR_FAIL_COND_V(image.is_compressed(),image);
+ ERR_FAIL_COND_V(image.is_compressed(), image);
image.convert(Image::FORMAT_RGBA8);
}
-
- r_gl_format=GL_RGBA;
- r_gl_internal_format=(config.srgb_decode_supported || p_flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)?GL_SRGB8_ALPHA8:GL_RGBA8;
- r_gl_type=GL_UNSIGNED_BYTE;
- r_compressed=false;
- srgb=true;
+ r_gl_format = GL_RGBA;
+ r_gl_internal_format = (config.srgb_decode_supported || p_flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) ? GL_SRGB8_ALPHA8 : GL_RGBA8;
+ r_gl_type = GL_UNSIGNED_BYTE;
+ r_compressed = false;
+ srgb = true;
return image;
-
}
-
return image;
}
-static const GLenum _cube_side_enum[6]={
+static const GLenum _cube_side_enum[6] = {
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -612,16 +575,15 @@ static const GLenum _cube_side_enum[6]={
RID RasterizerStorageGLES3::texture_create() {
Texture *texture = memnew(Texture);
- ERR_FAIL_COND_V(!texture,RID());
+ ERR_FAIL_COND_V(!texture, RID());
glGenTextures(1, &texture->tex_id);
- texture->active=false;
- texture->total_data_size=0;
-
- return texture_owner.make_rid( texture );
+ texture->active = false;
+ texture->total_data_size = 0;
+ return texture_owner.make_rid(texture);
}
-void RasterizerStorageGLES3::texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags) {
+void RasterizerStorageGLES3::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags) {
int components;
GLenum format;
@@ -631,56 +593,52 @@ void RasterizerStorageGLES3::texture_allocate(RID p_texture,int p_width, int p_h
bool compressed;
bool srgb;
- if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
- p_flags&=~VS::TEXTURE_FLAG_MIPMAPS; // no mipies for video
+ if (p_flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+ p_flags &= ~VS::TEXTURE_FLAG_MIPMAPS; // no mipies for video
}
-
- Texture *texture = texture_owner.get( p_texture );
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
- texture->width=p_width;
- texture->height=p_height;
- texture->format=p_format;
- texture->flags=p_flags;
- texture->stored_cube_sides=0;
+ texture->width = p_width;
+ texture->height = p_height;
+ texture->format = p_format;
+ texture->flags = p_flags;
+ texture->stored_cube_sides = 0;
texture->target = (p_flags & VS::TEXTURE_FLAG_CUBEMAP) ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
- _get_gl_image_and_format(Image(),texture->format,texture->flags,format,internal_format,type,compressed,srgb);
+ _get_gl_image_and_format(Image(), texture->format, texture->flags, format, internal_format, type, compressed, srgb);
texture->alloc_width = texture->width;
texture->alloc_height = texture->height;
-
- texture->gl_format_cache=format;
- texture->gl_type_cache=type;
- texture->gl_internal_format_cache=internal_format;
- texture->compressed=compressed;
- texture->srgb=srgb;
- texture->data_size=0;
- texture->mipmaps=1;
-
+ texture->gl_format_cache = format;
+ texture->gl_type_cache = type;
+ texture->gl_internal_format_cache = internal_format;
+ texture->compressed = compressed;
+ texture->srgb = srgb;
+ texture->data_size = 0;
+ texture->mipmaps = 1;
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target, texture->tex_id);
-
- if (p_flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+ if (p_flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
//prealloc if video
- glTexImage2D(texture->target, 0, internal_format, p_width, p_height, 0, format, type,NULL);
+ glTexImage2D(texture->target, 0, internal_format, p_width, p_height, 0, format, type, NULL);
}
- texture->active=true;
+ texture->active = true;
}
-void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) {
+void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side) {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
ERR_FAIL_COND(!texture->active);
ERR_FAIL_COND(texture->render_target);
- ERR_FAIL_COND(texture->format != p_image.get_format() );
- ERR_FAIL_COND( p_image.empty() );
+ ERR_FAIL_COND(texture->format != p_image.get_format());
+ ERR_FAIL_COND(p_image.empty());
GLenum type;
GLenum format;
@@ -688,32 +646,29 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image
bool compressed;
bool srgb;
-
- if (config.keep_original_textures && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
- texture->images[p_cube_side]=p_image;
+ if (config.keep_original_textures && !(texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
+ texture->images[p_cube_side] = p_image;
}
- Image img = _get_gl_image_and_format(p_image, p_image.get_format(),texture->flags,format,internal_format,type,compressed,srgb);
+ Image img = _get_gl_image_and_format(p_image, p_image.get_format(), texture->flags, format, internal_format, type, compressed, srgb);
- if (config.shrink_textures_x2 && (p_image.has_mipmaps() || !p_image.is_compressed()) && !(texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
+ if (config.shrink_textures_x2 && (p_image.has_mipmaps() || !p_image.is_compressed()) && !(texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING)) {
- texture->alloc_height = MAX(1,texture->alloc_height/2);
- texture->alloc_width = MAX(1,texture->alloc_width/2);
+ texture->alloc_height = MAX(1, texture->alloc_height / 2);
+ texture->alloc_width = MAX(1, texture->alloc_width / 2);
- if (texture->alloc_width == img.get_width()/2 && texture->alloc_height == img.get_height()/2) {
+ if (texture->alloc_width == img.get_width() / 2 && texture->alloc_height == img.get_height() / 2) {
img.shrink_x2();
} else if (img.get_format() <= Image::FORMAT_RGB565) {
img.resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
-
}
};
+ GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP) ? _cube_side_enum[p_cube_side] : GL_TEXTURE_2D;
- GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP)?_cube_side_enum[p_cube_side]:GL_TEXTURE_2D;
-
- texture->data_size=img.get_data().size();
+ texture->data_size = img.get_data().size();
PoolVector<uint8_t>::Read read = img.get_data().read();
glActiveTexture(GL_TEXTURE0);
@@ -721,87 +676,83 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image
texture->ignore_mipmaps = compressed && !img.has_mipmaps();
- if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps)
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,config.use_fast_texture_filter?GL_LINEAR_MIPMAP_NEAREST:GL_LINEAR_MIPMAP_LINEAR);
+ if (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps)
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, config.use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
else {
- if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+ if (texture->flags & VS::TEXTURE_FLAG_FILTER) {
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
-
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
}
-
if (config.srgb_decode_supported && srgb) {
- if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+ if (texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
- texture->using_srgb=true;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
+ texture->using_srgb = true;
} else {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
- texture->using_srgb=false;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT);
+ texture->using_srgb = false;
}
}
- if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+ if (texture->flags & VS::TEXTURE_FLAG_FILTER) {
- glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
+ glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtering
} else {
- glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering
+ glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // raw Filtering
}
- if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
+ if ((texture->flags & VS::TEXTURE_FLAG_REPEAT || texture->flags & VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
- if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
- }
- else{
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+ if (texture->flags & VS::TEXTURE_FLAG_MIRRORED_REPEAT) {
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+ } else {
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
} else {
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
- glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
- glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+ glTexParameterf(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameterf(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
- //set swizle for older format compatibility
+//set swizle for older format compatibility
#ifdef GLES_OVER_GL
- switch(texture->format) {
+ switch (texture->format) {
case Image::FORMAT_L8: {
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ONE);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ONE);
} break;
case Image::FORMAT_LA8: {
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_GREEN);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_GREEN);
} break;
default: {
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_R,GL_RED);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_G,GL_GREEN);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_B,GL_BLUE);
- glTexParameteri(texture->target,GL_TEXTURE_SWIZZLE_A,GL_ALPHA);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
+ glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
} break;
-
}
#endif
if (config.use_anisotropic_filter) {
- if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
+ if (texture->flags & VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
} else {
@@ -809,72 +760,66 @@ void RasterizerStorageGLES3::texture_set_data(RID p_texture,const Image& p_image
}
}
- int mipmaps= (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && img.has_mipmaps()) ? img.get_mipmap_count() +1: 1;
-
+ int mipmaps = (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && img.has_mipmaps()) ? img.get_mipmap_count() + 1 : 1;
- int w=img.get_width();
- int h=img.get_height();
+ int w = img.get_width();
+ int h = img.get_height();
- int tsize=0;
- for(int i=0;i<mipmaps;i++) {
+ int tsize = 0;
+ for (int i = 0; i < mipmaps; i++) {
- int size,ofs;
- img.get_mipmap_offset_and_size(i,ofs,size);
+ int size, ofs;
+ img.get_mipmap_offset_and_size(i, ofs, size);
//print_line("mipmap: "+itos(i)+" size: "+itos(size)+" w: "+itos(mm_w)+", h: "+itos(mm_h));
if (texture->compressed) {
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
- glCompressedTexImage2D( blit_target, i, internal_format,w,h,0,size,&read[ofs] );
+ glCompressedTexImage2D(blit_target, i, internal_format, w, h, 0, size, &read[ofs]);
} else {
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
- if (texture->flags&VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
- glTexSubImage2D( blit_target, i, 0,0,w, h,format,type,&read[ofs] );
+ if (texture->flags & VS::TEXTURE_FLAG_USED_FOR_STREAMING) {
+ glTexSubImage2D(blit_target, i, 0, 0, w, h, format, type, &read[ofs]);
} else {
- glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type,&read[ofs]);
+ glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type, &read[ofs]);
}
-
}
- tsize+=size;
-
- w = MAX(1,w>>1);
- h = MAX(1,h>>1);
+ tsize += size;
+ w = MAX(1, w >> 1);
+ h = MAX(1, h >> 1);
}
- info.texture_mem-=texture->total_data_size;
- texture->total_data_size=tsize;
- info.texture_mem+=texture->total_data_size;
+ info.texture_mem -= texture->total_data_size;
+ texture->total_data_size = tsize;
+ info.texture_mem += texture->total_data_size;
//printf("texture: %i x %i - size: %i - total: %i\n",texture->width,texture->height,tsize,_rinfo.texture_mem);
- texture->stored_cube_sides|=(1<<p_cube_side);
+ texture->stored_cube_sides |= (1 << p_cube_side);
- if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && mipmaps==1 && !texture->ignore_mipmaps && (!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides==(1<<6)-1)) {
+ if (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && mipmaps == 1 && !texture->ignore_mipmaps && (!(texture->flags & VS::TEXTURE_FLAG_CUBEMAP) || texture->stored_cube_sides == (1 << 6) - 1)) {
//generate mipmaps if they were requested and the image does not contain them
glGenerateMipmap(texture->target);
- } else if (mipmaps>1) {
+ } else if (mipmaps > 1) {
glTexParameteri(texture->target, GL_TEXTURE_BASE_LEVEL, 0);
- glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps-1);
-
+ glTexParameteri(texture->target, GL_TEXTURE_MAX_LEVEL, mipmaps - 1);
}
- texture->mipmaps=mipmaps;
+ texture->mipmaps = mipmaps;
//texture_set_flags(p_texture,texture->flags);
-
-
}
-Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const {
+Image RasterizerStorageGLES3::texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side) const {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,Image());
- ERR_FAIL_COND_V(!texture->active,Image());
- ERR_FAIL_COND_V(texture->data_size==0,Image());
- ERR_FAIL_COND_V(texture->render_target,Image());
+ ERR_FAIL_COND_V(!texture, Image());
+ ERR_FAIL_COND_V(!texture->active, Image());
+ ERR_FAIL_COND_V(texture->data_size == 0, Image());
+ ERR_FAIL_COND_V(texture->render_target, Image());
if (!texture->images[p_cube_side].empty())
return texture->images[p_cube_side];
@@ -883,46 +828,44 @@ Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_c
PoolVector<uint8_t> data;
- int data_size = Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,texture->mipmaps>1?-1:0);
+ int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, texture->format, texture->mipmaps > 1 ? -1 : 0);
- data.resize(data_size*2); //add some memory at the end, just in case for buggy drivers
+ data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
PoolVector<uint8_t>::Write wb = data.write();
glActiveTexture(GL_TEXTURE0);
- glBindTexture(texture->target,texture->tex_id);
+ glBindTexture(texture->target, texture->tex_id);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
- print_line("GET FORMAT: "+Image::get_format_name(texture->format)+" mipmaps: "+itos(texture->mipmaps));
-
+ print_line("GET FORMAT: " + Image::get_format_name(texture->format) + " mipmaps: " + itos(texture->mipmaps));
- for(int i=0;i<texture->mipmaps;i++) {
+ for (int i = 0; i < texture->mipmaps; i++) {
- int ofs=0;
- if (i>0) {
- ofs=Image::get_image_data_size(texture->alloc_width,texture->alloc_height,texture->format,i-1);
+ int ofs = 0;
+ if (i > 0) {
+ ofs = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, texture->format, i - 1);
}
if (texture->compressed) {
glPixelStorei(GL_PACK_ALIGNMENT, 4);
- glGetCompressedTexImage(texture->target,i,&wb[ofs]);
+ glGetCompressedTexImage(texture->target, i, &wb[ofs]);
} else {
glPixelStorei(GL_PACK_ALIGNMENT, 1);
- glGetTexImage(texture->target,i,texture->gl_format_cache,texture->gl_type_cache,&wb[ofs]);
+ glGetTexImage(texture->target, i, texture->gl_format_cache, texture->gl_type_cache, &wb[ofs]);
}
}
-
- wb=PoolVector<uint8_t>::Write();
+ wb = PoolVector<uint8_t>::Write();
data.resize(data_size);
- Image img(texture->alloc_width,texture->alloc_height,texture->mipmaps>1?true:false,texture->format,data);
+ Image img(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1 ? true : false, texture->format, data);
return img;
#else
@@ -932,44 +875,40 @@ Image RasterizerStorageGLES3::texture_get_data(RID p_texture,VS::CubeMapSide p_c
#endif
}
-void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) {
+void RasterizerStorageGLES3::texture_set_flags(RID p_texture, uint32_t p_flags) {
- Texture *texture = texture_owner.get( p_texture );
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
if (texture->render_target) {
- p_flags&=VS::TEXTURE_FLAG_FILTER;//can change only filter
+ p_flags &= VS::TEXTURE_FLAG_FILTER; //can change only filter
}
- bool had_mipmaps = texture->flags&VS::TEXTURE_FLAG_MIPMAPS;
+ bool had_mipmaps = texture->flags & VS::TEXTURE_FLAG_MIPMAPS;
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target, texture->tex_id);
uint32_t cube = texture->flags & VS::TEXTURE_FLAG_CUBEMAP;
- texture->flags=p_flags|cube; // can't remove a cube from being a cube
+ texture->flags = p_flags | cube; // can't remove a cube from being a cube
+ if ((texture->flags & VS::TEXTURE_FLAG_REPEAT || texture->flags & VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
- if ((texture->flags&VS::TEXTURE_FLAG_REPEAT || texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT) && texture->target != GL_TEXTURE_CUBE_MAP) {
-
- if (texture->flags&VS::TEXTURE_FLAG_MIRRORED_REPEAT){
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT );
- }
- else {
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
- glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+ if (texture->flags & VS::TEXTURE_FLAG_MIRRORED_REPEAT) {
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
+ } else {
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
} else {
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
- glTexParameterf( texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
- glTexParameterf( texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
-
+ glTexParameterf(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameterf(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
-
if (config.use_anisotropic_filter) {
- if (texture->flags&VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
+ if (texture->flags & VS::TEXTURE_FLAG_ANISOTROPIC_FILTER) {
glTexParameterf(texture->target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, config.anisotropic_level);
} else {
@@ -977,278 +916,256 @@ void RasterizerStorageGLES3::texture_set_flags(RID p_texture,uint32_t p_flags) {
}
}
- if (texture->flags&VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps) {
- if (!had_mipmaps && texture->mipmaps==1) {
+ if (texture->flags & VS::TEXTURE_FLAG_MIPMAPS && !texture->ignore_mipmaps) {
+ if (!had_mipmaps && texture->mipmaps == 1) {
glGenerateMipmap(texture->target);
}
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,config.use_fast_texture_filter?GL_LINEAR_MIPMAP_NEAREST:GL_LINEAR_MIPMAP_LINEAR);
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, config.use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
- } else{
- if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+ } else {
+ if (texture->flags & VS::TEXTURE_FLAG_FILTER) {
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
- glTexParameteri(texture->target,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
-
+ glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
}
-
if (config.srgb_decode_supported && texture->srgb) {
- if (texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
+ if (texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR) {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
- texture->using_srgb=true;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
+ texture->using_srgb = true;
} else {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_SKIP_DECODE_EXT);
- texture->using_srgb=false;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _SKIP_DECODE_EXT);
+ texture->using_srgb = false;
}
}
- if (texture->flags&VS::TEXTURE_FLAG_FILTER) {
+ if (texture->flags & VS::TEXTURE_FLAG_FILTER) {
- glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
+ glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Filtering
} else {
- glTexParameteri(texture->target,GL_TEXTURE_MAG_FILTER,GL_NEAREST); // raw Filtering
+ glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // raw Filtering
}
-
}
uint32_t RasterizerStorageGLES3::texture_get_flags(RID p_texture) const {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,0);
+ ERR_FAIL_COND_V(!texture, 0);
return texture->flags;
-
}
Image::Format RasterizerStorageGLES3::texture_get_format(RID p_texture) const {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,Image::FORMAT_L8);
+ ERR_FAIL_COND_V(!texture, Image::FORMAT_L8);
return texture->format;
}
uint32_t RasterizerStorageGLES3::texture_get_width(RID p_texture) const {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,0);
+ ERR_FAIL_COND_V(!texture, 0);
return texture->width;
}
uint32_t RasterizerStorageGLES3::texture_get_height(RID p_texture) const {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,0);
+ ERR_FAIL_COND_V(!texture, 0);
return texture->height;
}
+void RasterizerStorageGLES3::texture_set_size_override(RID p_texture, int p_width, int p_height) {
-void RasterizerStorageGLES3::texture_set_size_override(RID p_texture,int p_width, int p_height) {
-
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
ERR_FAIL_COND(texture->render_target);
- ERR_FAIL_COND(p_width<=0 || p_width>16384);
- ERR_FAIL_COND(p_height<=0 || p_height>16384);
+ ERR_FAIL_COND(p_width <= 0 || p_width > 16384);
+ ERR_FAIL_COND(p_height <= 0 || p_height > 16384);
//real texture size is in alloc width and height
- texture->width=p_width;
- texture->height=p_height;
-
+ texture->width = p_width;
+ texture->height = p_height;
}
-void RasterizerStorageGLES3::texture_set_path(RID p_texture,const String& p_path) {
- Texture * texture = texture_owner.get(p_texture);
+void RasterizerStorageGLES3::texture_set_path(RID p_texture, const String &p_path) {
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
- texture->path=p_path;
-
+ texture->path = p_path;
}
-String RasterizerStorageGLES3::texture_get_path(RID p_texture) const{
+String RasterizerStorageGLES3::texture_get_path(RID p_texture) const {
- Texture * texture = texture_owner.get(p_texture);
- ERR_FAIL_COND_V(!texture,String());
+ Texture *texture = texture_owner.get(p_texture);
+ ERR_FAIL_COND_V(!texture, String());
return texture->path;
}
-void RasterizerStorageGLES3::texture_debug_usage(List<VS::TextureInfo> *r_info){
+void RasterizerStorageGLES3::texture_debug_usage(List<VS::TextureInfo> *r_info) {
List<RID> textures;
texture_owner.get_owned_list(&textures);
- for (List<RID>::Element *E=textures.front();E;E=E->next()) {
+ for (List<RID>::Element *E = textures.front(); E; E = E->next()) {
Texture *t = texture_owner.get(E->get());
if (!t)
continue;
VS::TextureInfo tinfo;
- tinfo.path=t->path;
- tinfo.format=t->format;
- tinfo.size.x=t->alloc_width;
- tinfo.size.y=t->alloc_height;
- tinfo.bytes=t->total_data_size;
+ tinfo.path = t->path;
+ tinfo.format = t->format;
+ tinfo.size.x = t->alloc_width;
+ tinfo.size.y = t->alloc_height;
+ tinfo.bytes = t->total_data_size;
r_info->push_back(tinfo);
}
-
}
void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
- config.shrink_textures_x2=p_enable;
+ config.shrink_textures_x2 = p_enable;
}
void RasterizerStorageGLES3::textures_keep_original(bool p_enable) {
- config.keep_original_textures=p_enable;
+ config.keep_original_textures = p_enable;
}
-void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata) {
+void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata) {
- Texture * texture = texture_owner.get(p_texture);
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
- texture->detect_3d=p_callback;
- texture->detect_3d_ud=p_userdata;
+ texture->detect_3d = p_callback;
+ texture->detect_3d_ud = p_userdata;
}
-void RasterizerStorageGLES3::texture_set_detect_srgb_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata){
- Texture * texture = texture_owner.get(p_texture);
+void RasterizerStorageGLES3::texture_set_detect_srgb_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata) {
+ Texture *texture = texture_owner.get(p_texture);
ERR_FAIL_COND(!texture);
- texture->detect_srgb=p_callback;
- texture->detect_srgb_ud=p_userdata;
-
+ texture->detect_srgb = p_callback;
+ texture->detect_srgb_ud = p_userdata;
}
+RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source, int p_resolution) const {
+ Texture *texture = texture_owner.get(p_source);
+ ERR_FAIL_COND_V(!texture, RID());
+ ERR_FAIL_COND_V(!(texture->flags & VS::TEXTURE_FLAG_CUBEMAP), RID());
-RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_resolution) const {
-
- Texture * texture = texture_owner.get(p_source);
- ERR_FAIL_COND_V(!texture,RID());
- ERR_FAIL_COND_V(!(texture->flags&VS::TEXTURE_FLAG_CUBEMAP),RID());
-
- bool use_float=config.hdr_supported;
+ bool use_float = config.hdr_supported;
- if (p_resolution<0) {
- p_resolution=texture->width;
+ if (p_resolution < 0) {
+ p_resolution = texture->width;
}
-
glBindVertexArray(0);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
-
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target, texture->tex_id);
if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
- texture->using_srgb=true;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
+ texture->using_srgb = true;
#ifdef TOOLS_ENABLED
- if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
- texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+ if (!(texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+ texture->flags |= VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
//notify that texture must be set to linear beforehand, so it works in other platforms when exported
}
#endif
}
-
glActiveTexture(GL_TEXTURE1);
GLuint new_cubemap;
glGenTextures(1, &new_cubemap);
glBindTexture(GL_TEXTURE_CUBE_MAP, new_cubemap);
-
GLuint tmp_fb;
glGenFramebuffers(1, &tmp_fb);
glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
-
int size = p_resolution;
- int lod=0;
+ int lod = 0;
shaders.cubemap_filter.bind();
- int mipmaps=6;
+ int mipmaps = 6;
- int mm_level=mipmaps;
+ int mm_level = mipmaps;
- GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+ GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2;
GLenum format = GL_RGBA;
- GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+ GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV;
+ while (mm_level) {
- while(mm_level) {
-
- for(int i=0;i<6;i++) {
- glTexImage2D(_cube_side_enum[i], lod, internal_format, size, size, 0, format, type, NULL);
+ for (int i = 0; i < 6; i++) {
+ glTexImage2D(_cube_side_enum[i], lod, internal_format, size, size, 0, format, type, NULL);
}
lod++;
mm_level--;
- if (size>1)
- size>>=1;
+ if (size > 1)
+ size >>= 1;
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
- glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod - 1);
- lod=0;
- mm_level=mipmaps;
+ lod = 0;
+ mm_level = mipmaps;
size = p_resolution;
- shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
+ shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, false);
- while(mm_level) {
+ while (mm_level) {
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], new_cubemap, lod);
- glViewport(0,0,size,size);
+ glViewport(0, 0, size, size);
glBindVertexArray(resources.quadie_array);
- shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID,i);
- shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
-
+ shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::FACE_ID, i);
+ shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS, lod / float(mipmaps - 1));
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
#ifdef DEBUG_ENABLED
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
#endif
}
-
-
- if (size>1)
- size>>=1;
+ if (size > 1)
+ size >>= 1;
lod++;
mm_level--;
-
}
-
//restore ranges
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
- glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod-1);
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, lod - 1);
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -1259,59 +1176,58 @@ RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source,int p_r
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
glDeleteFramebuffers(1, &tmp_fb);
- Texture * ctex = memnew( Texture );
+ Texture *ctex = memnew(Texture);
- ctex->flags=VS::TEXTURE_FLAG_CUBEMAP|VS::TEXTURE_FLAG_MIPMAPS|VS::TEXTURE_FLAG_FILTER;
- ctex->width=p_resolution;
- ctex->height=p_resolution;
- ctex->alloc_width=p_resolution;
- ctex->alloc_height=p_resolution;
- ctex->format=use_float?Image::FORMAT_RGBAH:Image::FORMAT_RGBA8;
- ctex->target=GL_TEXTURE_CUBE_MAP;
- ctex->gl_format_cache=format;
- ctex->gl_internal_format_cache=internal_format;
- ctex->gl_type_cache=type;
- ctex->data_size=0;
- ctex->compressed=false;
- ctex->srgb=false;
- ctex->total_data_size=0;
- ctex->ignore_mipmaps=false;
- ctex->mipmaps=mipmaps;
- ctex->active=true;
- ctex->tex_id=new_cubemap;
- ctex->stored_cube_sides=(1<<6)-1;
- ctex->render_target=NULL;
+ ctex->flags = VS::TEXTURE_FLAG_CUBEMAP | VS::TEXTURE_FLAG_MIPMAPS | VS::TEXTURE_FLAG_FILTER;
+ ctex->width = p_resolution;
+ ctex->height = p_resolution;
+ ctex->alloc_width = p_resolution;
+ ctex->alloc_height = p_resolution;
+ ctex->format = use_float ? Image::FORMAT_RGBAH : Image::FORMAT_RGBA8;
+ ctex->target = GL_TEXTURE_CUBE_MAP;
+ ctex->gl_format_cache = format;
+ ctex->gl_internal_format_cache = internal_format;
+ ctex->gl_type_cache = type;
+ ctex->data_size = 0;
+ ctex->compressed = false;
+ ctex->srgb = false;
+ ctex->total_data_size = 0;
+ ctex->ignore_mipmaps = false;
+ ctex->mipmaps = mipmaps;
+ ctex->active = true;
+ ctex->tex_id = new_cubemap;
+ ctex->stored_cube_sides = (1 << 6) - 1;
+ ctex->render_target = NULL;
return texture_owner.make_rid(ctex);
}
-
RID RasterizerStorageGLES3::skybox_create() {
- SkyBox *skybox = memnew( SkyBox );
- skybox->radiance=0;
+ SkyBox *skybox = memnew(SkyBox);
+ skybox->radiance = 0;
return skybox_owner.make_rid(skybox);
}
-void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size){
+void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size) {
SkyBox *skybox = skybox_owner.getornull(p_skybox);
ERR_FAIL_COND(!skybox);
if (skybox->cubemap.is_valid()) {
- skybox->cubemap=RID();
- glDeleteTextures(1,&skybox->radiance);
- skybox->radiance=0;
+ skybox->cubemap = RID();
+ glDeleteTextures(1, &skybox->radiance);
+ skybox->radiance = 0;
}
- skybox->cubemap=p_cube_map;
+ skybox->cubemap = p_cube_map;
if (!skybox->cubemap.is_valid())
return; //cleared
Texture *texture = texture_owner.getornull(skybox->cubemap);
- if (!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP)) {
- skybox->cubemap=RID();
- ERR_FAIL_COND(!texture || !(texture->flags&VS::TEXTURE_FLAG_CUBEMAP));
+ if (!texture || !(texture->flags & VS::TEXTURE_FLAG_CUBEMAP)) {
+ skybox->cubemap = RID();
+ ERR_FAIL_COND(!texture || !(texture->flags & VS::TEXTURE_FLAG_CUBEMAP));
}
glBindVertexArray(0);
@@ -1320,23 +1236,21 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
-
glActiveTexture(GL_TEXTURE0);
glBindTexture(texture->target, texture->tex_id);
if (config.srgb_decode_supported && texture->srgb && !texture->using_srgb) {
- glTexParameteri(texture->target,_TEXTURE_SRGB_DECODE_EXT,_DECODE_EXT);
- texture->using_srgb=true;
+ glTexParameteri(texture->target, _TEXTURE_SRGB_DECODE_EXT, _DECODE_EXT);
+ texture->using_srgb = true;
#ifdef TOOLS_ENABLED
- if (!(texture->flags&VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
- texture->flags|=VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
+ if (!(texture->flags & VS::TEXTURE_FLAG_CONVERT_TO_LINEAR)) {
+ texture->flags |= VS::TEXTURE_FLAG_CONVERT_TO_LINEAR;
//notify that texture must be set to linear beforehand, so it works in other platforms when exported
}
#endif
}
-
glActiveTexture(GL_TEXTURE1);
glGenTextures(1, &skybox->radiance);
glBindTexture(GL_TEXTURE_2D, skybox->radiance);
@@ -1346,75 +1260,70 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in
glGenFramebuffers(1, &tmp_fb);
glBindFramebuffer(GL_FRAMEBUFFER, tmp_fb);
-
int size = p_radiance_size;
- int lod=0;
-
+ int lod = 0;
- int mipmaps=6;
+ int mipmaps = 6;
- int mm_level=mipmaps;
+ int mm_level = mipmaps;
- bool use_float=config.hdr_supported;
+ bool use_float = config.hdr_supported;
- GLenum internal_format = use_float?GL_RGBA16F:GL_RGB10_A2;
+ GLenum internal_format = use_float ? GL_RGBA16F : GL_RGB10_A2;
GLenum format = GL_RGBA;
- GLenum type = use_float?GL_HALF_FLOAT:GL_UNSIGNED_INT_2_10_10_10_REV;
+ GLenum type = use_float ? GL_HALF_FLOAT : GL_UNSIGNED_INT_2_10_10_10_REV;
- while(mm_level) {
+ while (mm_level) {
- glTexImage2D(GL_TEXTURE_2D, lod, internal_format, size, size*2, 0, format, type, NULL);
+ glTexImage2D(GL_TEXTURE_2D, lod, internal_format, size, size * 2, 0, format, type, NULL);
lod++;
mm_level--;
- if (size>1)
- size>>=1;
+ if (size > 1)
+ size >>= 1;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod - 1);
- lod=0;
- mm_level=mipmaps;
+ lod = 0;
+ mm_level = mipmaps;
size = p_radiance_size;
- shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,true);
+ shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, true);
shaders.cubemap_filter.bind();
- while(mm_level) {
+ while (mm_level) {
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, skybox->radiance, lod);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, skybox->radiance, lod);
#ifdef DEBUG_ENABLED
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
- ERR_CONTINUE(status!=GL_FRAMEBUFFER_COMPLETE);
+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);
#endif
- for(int i=0;i<2;i++) {
- glViewport(0,i*size,size,size);
+ for (int i = 0; i < 2; i++) {
+ glViewport(0, i * size, size, size);
glBindVertexArray(resources.quadie_array);
- shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP,i>0);
- shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS,lod/float(mipmaps-1));
+ shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::Z_FLIP, i > 0);
+ shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES3::ROUGHNESS, lod / float(mipmaps - 1));
-
- glDrawArrays(GL_TRIANGLE_FAN,0,4);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
}
- if (size>1)
- size>>=1;
+ if (size > 1)
+ size >>= 1;
lod++;
mm_level--;
-
}
- shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID,false);
-
+ shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES3::USE_DUAL_PARABOLOID, false);
//restore ranges
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod-1);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lod - 1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -1423,26 +1332,23 @@ void RasterizerStorageGLES3::skybox_set_texture(RID p_skybox, RID p_cube_map, in
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
glDeleteFramebuffers(1, &tmp_fb);
-
}
-
/* SHADER API */
+RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode) {
-RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){
-
- Shader *shader = memnew( Shader );
- shader->mode=p_mode;
+ Shader *shader = memnew(Shader);
+ shader->mode = p_mode;
RID rid = shader_owner.make_rid(shader);
- shader_set_mode(rid,p_mode);
+ shader_set_mode(rid, p_mode);
_shader_make_dirty(shader);
- shader->self=rid;
+ shader->self = rid;
return rid;
}
-void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) {
+void RasterizerStorageGLES3::_shader_make_dirty(Shader *p_shader) {
if (p_shader->dirty_list.in_list())
return;
@@ -1450,217 +1356,212 @@ void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) {
_shader_dirty_list.add(&p_shader->dirty_list);
}
-void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){
+void RasterizerStorageGLES3::shader_set_mode(RID p_shader, VS::ShaderMode p_mode) {
- ERR_FAIL_INDEX(p_mode,VS::SHADER_MAX);
- Shader *shader=shader_owner.get(p_shader);
+ ERR_FAIL_INDEX(p_mode, VS::SHADER_MAX);
+ Shader *shader = shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
- if (shader->custom_code_id && p_mode==shader->mode)
+ if (shader->custom_code_id && p_mode == shader->mode)
return;
-
if (shader->custom_code_id) {
shader->shader->free_custom_shader(shader->custom_code_id);
- shader->custom_code_id=0;
+ shader->custom_code_id = 0;
}
- shader->mode=p_mode;
+ shader->mode = p_mode;
- ShaderGLES3* shaders[VS::SHADER_MAX]={
+ ShaderGLES3 *shaders[VS::SHADER_MAX] = {
&scene->state.scene_shader,
&canvas->state.canvas_shader,
&this->shaders.particles,
};
- shader->shader=shaders[p_mode];
+ shader->shader = shaders[p_mode];
shader->custom_code_id = shader->shader->create_custom_shader();
_shader_make_dirty(shader);
-
}
VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const {
- const Shader *shader=shader_owner.get(p_shader);
- ERR_FAIL_COND_V(!shader,VS::SHADER_MAX);
+ const Shader *shader = shader_owner.get(p_shader);
+ ERR_FAIL_COND_V(!shader, VS::SHADER_MAX);
return shader->mode;
}
-void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){
+void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String &p_code) {
- Shader *shader=shader_owner.get(p_shader);
+ Shader *shader = shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
- shader->code=p_code;
+ shader->code = p_code;
_shader_make_dirty(shader);
}
-String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{
-
- const Shader *shader=shader_owner.get(p_shader);
- ERR_FAIL_COND_V(!shader,String());
+String RasterizerStorageGLES3::shader_get_code(RID p_shader) const {
+ const Shader *shader = shader_owner.get(p_shader);
+ ERR_FAIL_COND_V(!shader, String());
return shader->code;
}
-void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const {
-
+void RasterizerStorageGLES3::_update_shader(Shader *p_shader) const {
- _shader_dirty_list.remove( &p_shader->dirty_list );
+ _shader_dirty_list.remove(&p_shader->dirty_list);
- p_shader->valid=false;
+ p_shader->valid = false;
p_shader->uniforms.clear();
ShaderCompilerGLES3::GeneratedCode gen_code;
- ShaderCompilerGLES3::IdentifierActions *actions=NULL;
+ ShaderCompilerGLES3::IdentifierActions *actions = NULL;
-
-
- switch(p_shader->mode) {
+ switch (p_shader->mode) {
case VS::SHADER_CANVAS_ITEM: {
- p_shader->canvas_item.light_mode=Shader::CanvasItem::LIGHT_MODE_NORMAL;
- p_shader->canvas_item.blend_mode=Shader::CanvasItem::BLEND_MODE_MIX;
+ p_shader->canvas_item.light_mode = Shader::CanvasItem::LIGHT_MODE_NORMAL;
+ p_shader->canvas_item.blend_mode = Shader::CanvasItem::BLEND_MODE_MIX;
- shaders.actions_canvas.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_ADD);
- shaders.actions_canvas.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MIX);
- shaders.actions_canvas.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_SUB);
- shaders.actions_canvas.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MUL);
- shaders.actions_canvas.render_mode_values["blend_premul_alpha"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_PMALPHA);
+ shaders.actions_canvas.render_mode_values["blend_add"] = Pair<int *, int>(&p_shader->canvas_item.blend_mode, Shader::CanvasItem::BLEND_MODE_ADD);
+ shaders.actions_canvas.render_mode_values["blend_mix"] = Pair<int *, int>(&p_shader->canvas_item.blend_mode, Shader::CanvasItem::BLEND_MODE_MIX);
+ shaders.actions_canvas.render_mode_values["blend_sub"] = Pair<int *, int>(&p_shader->canvas_item.blend_mode, Shader::CanvasItem::BLEND_MODE_SUB);
+ shaders.actions_canvas.render_mode_values["blend_mul"] = Pair<int *, int>(&p_shader->canvas_item.blend_mode, Shader::CanvasItem::BLEND_MODE_MUL);
+ shaders.actions_canvas.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&p_shader->canvas_item.blend_mode, Shader::CanvasItem::BLEND_MODE_PMALPHA);
- shaders.actions_canvas.render_mode_values["unshaded"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_UNSHADED);
- shaders.actions_canvas.render_mode_values["light_only"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY);
+ shaders.actions_canvas.render_mode_values["unshaded"] = Pair<int *, int>(&p_shader->canvas_item.light_mode, Shader::CanvasItem::LIGHT_MODE_UNSHADED);
+ shaders.actions_canvas.render_mode_values["light_only"] = Pair<int *, int>(&p_shader->canvas_item.light_mode, Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY);
- actions=&shaders.actions_canvas;
- actions->uniforms=&p_shader->uniforms;
+ actions = &shaders.actions_canvas;
+ 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.uses_discard=false;
- p_shader->spatial.unshaded=false;
- p_shader->spatial.ontop=false;
- p_shader->spatial.uses_sss=false;
- p_shader->spatial.uses_vertex=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);
+ 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.uses_discard = false;
+ p_shader->spatial.unshaded = false;
+ p_shader->spatial.ontop = false;
+ p_shader->spatial.uses_sss = false;
+ p_shader->spatial.uses_vertex = false;
- 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["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["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_disabled"]=Pair<int*,int>(&p_shader->spatial.cull_mode,Shader::Spatial::CULL_MODE_DISABLED);
+ 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_flags["unshaded"]=&p_shader->spatial.unshaded;
- shaders.actions_scene.render_mode_flags["ontop"]=&p_shader->spatial.ontop;
+ 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_disabled"] = Pair<int *, int>(&p_shader->spatial.cull_mode, Shader::Spatial::CULL_MODE_DISABLED);
- shaders.actions_scene.usage_flag_pointers["ALPHA"]=&p_shader->spatial.uses_alpha;
- shaders.actions_scene.usage_flag_pointers["VERTEX"]=&p_shader->spatial.uses_vertex;
+ shaders.actions_scene.render_mode_flags["unshaded"] = &p_shader->spatial.unshaded;
+ shaders.actions_scene.render_mode_flags["ontop"] = &p_shader->spatial.ontop;
- shaders.actions_scene.usage_flag_pointers["SSS_STRENGTH"]=&p_shader->spatial.uses_sss;
- shaders.actions_scene.usage_flag_pointers["DISCARD"]=&p_shader->spatial.uses_discard;
+ shaders.actions_scene.usage_flag_pointers["ALPHA"] = &p_shader->spatial.uses_alpha;
+ shaders.actions_scene.usage_flag_pointers["VERTEX"] = &p_shader->spatial.uses_vertex;
- actions=&shaders.actions_scene;
- actions->uniforms=&p_shader->uniforms;
+ shaders.actions_scene.usage_flag_pointers["SSS_STRENGTH"] = &p_shader->spatial.uses_sss;
+ shaders.actions_scene.usage_flag_pointers["DISCARD"] = &p_shader->spatial.uses_discard;
+ actions = &shaders.actions_scene;
+ actions->uniforms = &p_shader->uniforms;
} break;
case VS::SHADER_PARTICLES: {
- actions=&shaders.actions_particles;
- actions->uniforms=&p_shader->uniforms;
+ actions = &shaders.actions_particles;
+ actions->uniforms = &p_shader->uniforms;
} break;
-
}
+ Error err = shaders.compiler.compile(p_shader->mode, p_shader->code, actions, p_shader->path, gen_code);
- Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code);
-
+ ERR_FAIL_COND(err != OK);
- ERR_FAIL_COND(err!=OK);
+ p_shader->shader->set_custom_shader_code(p_shader->custom_code_id, gen_code.vertex, gen_code.vertex_global, gen_code.fragment, gen_code.light, gen_code.fragment_global, gen_code.uniforms, gen_code.texture_uniforms, gen_code.defines);
- p_shader->shader->set_custom_shader_code(p_shader->custom_code_id,gen_code.vertex,gen_code.vertex_global,gen_code.fragment,gen_code.light,gen_code.fragment_global,gen_code.uniforms,gen_code.texture_uniforms,gen_code.defines);
+ p_shader->ubo_size = gen_code.uniform_total_size;
+ p_shader->ubo_offsets = gen_code.uniform_offsets;
+ p_shader->texture_count = gen_code.texture_uniforms.size();
+ p_shader->texture_hints = gen_code.texture_hints;
- p_shader->ubo_size=gen_code.uniform_total_size;
- p_shader->ubo_offsets=gen_code.uniform_offsets;
- p_shader->texture_count=gen_code.texture_uniforms.size();
- p_shader->texture_hints=gen_code.texture_hints;
-
- p_shader->uses_vertex_time=gen_code.uses_vertex_time;
- p_shader->uses_fragment_time=gen_code.uses_fragment_time;
+ p_shader->uses_vertex_time = gen_code.uses_vertex_time;
+ p_shader->uses_fragment_time = gen_code.uses_fragment_time;
//all materials using this shader will have to be invalidated, unfortunately
- for (SelfList<Material>* E = p_shader->materials.first();E;E=E->next() ) {
+ for (SelfList<Material> *E = p_shader->materials.first(); E; E = E->next()) {
_material_make_dirty(E->self());
}
- p_shader->valid=true;
+ p_shader->valid = true;
p_shader->version++;
-
-
}
void RasterizerStorageGLES3::update_dirty_shaders() {
- while( _shader_dirty_list.first() ) {
- _update_shader(_shader_dirty_list.first()->self() );
+ while (_shader_dirty_list.first()) {
+ _update_shader(_shader_dirty_list.first()->self());
}
}
-void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{
+void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
- Shader *shader=shader_owner.get(p_shader);
+ Shader *shader = shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
-
if (shader->dirty_list.in_list())
_update_shader(shader); // ok should be not anymore dirty
+ Map<int, StringName> order;
- Map<int,StringName> order;
-
+ for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = shader->uniforms.front(); E; E = E->next()) {
- for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
-
-
- order[E->get().order]=E->key();
+ order[E->get().order] = E->key();
}
-
- for(Map<int,StringName>::Element *E=order.front();E;E=E->next()) {
+ for (Map<int, StringName>::Element *E = order.front(); E; E = E->next()) {
PropertyInfo pi;
- ShaderLanguage::ShaderNode::Uniform &u=shader->uniforms[E->get()];
- pi.name=E->get();
- switch(u.type) {
- case ShaderLanguage::TYPE_VOID: pi.type=Variant::NIL; break;
- case ShaderLanguage::TYPE_BOOL: pi.type=Variant::BOOL; break;
- case ShaderLanguage::TYPE_BVEC2: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y"; break;
- case ShaderLanguage::TYPE_BVEC3: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z"; break;
- case ShaderLanguage::TYPE_BVEC4: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z,w"; break;
+ ShaderLanguage::ShaderNode::Uniform &u = shader->uniforms[E->get()];
+ pi.name = E->get();
+ switch (u.type) {
+ case ShaderLanguage::TYPE_VOID: pi.type = Variant::NIL; break;
+ case ShaderLanguage::TYPE_BOOL: pi.type = Variant::BOOL; break;
+ case ShaderLanguage::TYPE_BVEC2:
+ pi.type = Variant::INT;
+ pi.hint = PROPERTY_HINT_FLAGS;
+ pi.hint_string = "x,y";
+ break;
+ case ShaderLanguage::TYPE_BVEC3:
+ pi.type = Variant::INT;
+ pi.hint = PROPERTY_HINT_FLAGS;
+ pi.hint_string = "x,y,z";
+ break;
+ case ShaderLanguage::TYPE_BVEC4:
+ pi.type = Variant::INT;
+ pi.hint = PROPERTY_HINT_FLAGS;
+ pi.hint_string = "x,y,z,w";
+ break;
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_INT: {
- pi.type=Variant::INT;
- if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
- pi.hint=PROPERTY_HINT_RANGE;
- pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1]);
+ pi.type = Variant::INT;
+ if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
+ pi.hint = PROPERTY_HINT_RANGE;
+ pi.hint_string = rtos(u.hint_range[0]) + "," + rtos(u.hint_range[1]);
}
} break;
@@ -1671,77 +1572,75 @@ void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyIn
case ShaderLanguage::TYPE_UVEC3:
case ShaderLanguage::TYPE_UVEC4: {
- pi.type=Variant::POOL_INT_ARRAY;
+ pi.type = Variant::POOL_INT_ARRAY;
} break;
case ShaderLanguage::TYPE_FLOAT: {
- pi.type=Variant::REAL;
- if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
- pi.hint=PROPERTY_HINT_RANGE;
- pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1])+","+rtos(u.hint_range[2]);
+ pi.type = Variant::REAL;
+ if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
+ pi.hint = PROPERTY_HINT_RANGE;
+ pi.hint_string = rtos(u.hint_range[0]) + "," + rtos(u.hint_range[1]) + "," + rtos(u.hint_range[2]);
}
} break;
- case ShaderLanguage::TYPE_VEC2: pi.type=Variant::VECTOR2; break;
- case ShaderLanguage::TYPE_VEC3: pi.type=Variant::VECTOR3; break;
+ case ShaderLanguage::TYPE_VEC2: pi.type = Variant::VECTOR2; break;
+ case ShaderLanguage::TYPE_VEC3: pi.type = Variant::VECTOR3; break;
case ShaderLanguage::TYPE_VEC4: {
- if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
- pi.type=Variant::COLOR;
+ if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
+ pi.type = Variant::COLOR;
} else {
- pi.type=Variant::PLANE;
+ pi.type = Variant::PLANE;
}
} break;
- case ShaderLanguage::TYPE_MAT2: pi.type=Variant::TRANSFORM2D; break;
- case ShaderLanguage::TYPE_MAT3: pi.type=Variant::BASIS; break;
- case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
+ case ShaderLanguage::TYPE_MAT2: pi.type = Variant::TRANSFORM2D; break;
+ case ShaderLanguage::TYPE_MAT3: pi.type = Variant::BASIS; break;
+ case ShaderLanguage::TYPE_MAT4: pi.type = Variant::TRANSFORM; break;
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D: {
- pi.type=Variant::OBJECT;
- pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
- pi.hint_string="Texture";
+ pi.type = Variant::OBJECT;
+ pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
+ pi.hint_string = "Texture";
} break;
case ShaderLanguage::TYPE_SAMPLERCUBE: {
- pi.type=Variant::OBJECT;
- pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
- pi.hint_string="CubeMap";
+ pi.type = Variant::OBJECT;
+ pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
+ pi.hint_string = "CubeMap";
} break;
};
p_param_list->push_back(pi);
-
}
}
-void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){
+void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
- Shader *shader=shader_owner.get(p_shader);
+ Shader *shader = shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
if (p_texture.is_valid())
- shader->default_textures[p_name]=p_texture;
+ shader->default_textures[p_name] = p_texture;
else
shader->default_textures.erase(p_name);
_shader_make_dirty(shader);
}
-RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
+RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
- const Shader *shader=shader_owner.get(p_shader);
- ERR_FAIL_COND_V(!shader,RID());
+ const Shader *shader = shader_owner.get(p_shader);
+ ERR_FAIL_COND_V(!shader, RID());
- const Map<StringName,RID>::Element *E=shader->default_textures.find(p_name);
+ const Map<StringName, RID>::Element *E = shader->default_textures.find(p_name);
if (!E)
return RID();
return E->get();
}
-
/* COMMON MATERIAL API */
-void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
+void RasterizerStorageGLES3::_material_make_dirty(Material *p_material) const {
if (p_material->dirty_list.in_list())
return;
@@ -1749,38 +1648,37 @@ void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
_material_dirty_list.add(&p_material->dirty_list);
}
-RID RasterizerStorageGLES3::material_create(){
+RID RasterizerStorageGLES3::material_create() {
- Material *material = memnew( Material );
+ Material *material = memnew(Material);
return material_owner.make_rid(material);
}
-void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader){
+void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader) {
- Material *material = material_owner.get( p_material );
+ Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- Shader *shader=shader_owner.getornull(p_shader);
+ Shader *shader = shader_owner.getornull(p_shader);
if (material->shader) {
//if shader, remove from previous shader material list
- material->shader->materials.remove( &material->list );
+ material->shader->materials.remove(&material->list);
}
- material->shader=shader;
+ material->shader = shader;
if (shader) {
shader->materials.add(&material->list);
}
_material_make_dirty(material);
-
}
-RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{
+RID RasterizerStorageGLES3::material_get_shader(RID p_material) const {
- const Material *material = material_owner.get( p_material );
- ERR_FAIL_COND_V(!material,RID());
+ const Material *material = material_owner.get(p_material);
+ ERR_FAIL_COND_V(!material, RID());
if (material->shader)
return material->shader->self;
@@ -1788,23 +1686,22 @@ RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{
return RID();
}
-void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){
+void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
- Material *material = material_owner.get( p_material );
+ Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- if (p_value.get_type()==Variant::NIL)
+ if (p_value.get_type() == Variant::NIL)
material->params.erase(p_param);
else
- material->params[p_param]=p_value;
+ material->params[p_param] = p_value;
_material_make_dirty(material);
-
}
-Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{
+Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName &p_param) const {
- const Material *material = material_owner.get( p_material );
- ERR_FAIL_COND_V(!material,RID());
+ const Material *material = material_owner.get(p_material);
+ ERR_FAIL_COND_V(!material, RID());
if (material->params.has(p_param))
return material->params[p_param];
@@ -1814,29 +1711,26 @@ Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringN
void RasterizerStorageGLES3::material_set_line_width(RID p_material, float p_width) {
- Material *material = material_owner.get( p_material );
+ Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- material->line_width=p_width;
-
-
+ material->line_width = p_width;
}
-bool RasterizerStorageGLES3::material_is_animated(RID p_material) {
+bool RasterizerStorageGLES3::material_is_animated(RID p_material) {
- Material *material = material_owner.get( p_material );
- ERR_FAIL_COND_V(!material,false);
+ Material *material = material_owner.get(p_material);
+ ERR_FAIL_COND_V(!material, false);
if (material->dirty_list.in_list()) {
_update_material(material);
}
return material->is_animated_cache;
-
}
-bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) {
+bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) {
- Material *material = material_owner.get( p_material );
- ERR_FAIL_COND_V(!material,false);
+ Material *material = material_owner.get(p_material);
+ ERR_FAIL_COND_V(!material, false);
if (material->dirty_list.in_list()) {
_update_material(material);
}
@@ -1846,90 +1740,87 @@ bool RasterizerStorageGLES3::material_casts_shadows(RID p_material) {
void RasterizerStorageGLES3::material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
- Material *material = material_owner.get( p_material );
+ Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
+ Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.find(p_instance);
if (E) {
E->get()++;
} else {
- material->instance_owners[p_instance]=1;
+ material->instance_owners[p_instance] = 1;
}
}
void RasterizerStorageGLES3::material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance) {
- Material *material = material_owner.get( p_material );
+ Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.find(p_instance);
+ Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.find(p_instance);
ERR_FAIL_COND(!E);
E->get()--;
- if (E->get()==0) {
+ if (E->get() == 0) {
material->instance_owners.erase(E);
}
}
-
-
-_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data,bool p_linear_color) {
- switch(type) {
+_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant &value, uint8_t *data, bool p_linear_color) {
+ switch (type) {
case ShaderLanguage::TYPE_BOOL: {
bool v = value;
- GLuint *gui = (GLuint*)data;
+ GLuint *gui = (GLuint *)data;
*gui = v ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC2: {
int v = value;
- GLuint *gui = (GLuint*)data;
- gui[0]=v&1 ? GL_TRUE : GL_FALSE;
- gui[1]=v&2 ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = v & 1 ? GL_TRUE : GL_FALSE;
+ gui[1] = v & 2 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC3: {
int v = value;
- GLuint *gui = (GLuint*)data;
- gui[0]=v&1 ? GL_TRUE : GL_FALSE;
- gui[1]=v&2 ? GL_TRUE : GL_FALSE;
- gui[2]=v&4 ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = v & 1 ? GL_TRUE : GL_FALSE;
+ gui[1] = v & 2 ? GL_TRUE : GL_FALSE;
+ gui[2] = v & 4 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC4: {
int v = value;
- GLuint *gui = (GLuint*)data;
- gui[0]=v&1 ? GL_TRUE : GL_FALSE;
- gui[1]=v&2 ? GL_TRUE : GL_FALSE;
- gui[2]=v&4 ? GL_TRUE : GL_FALSE;
- gui[3]=v&8 ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = v & 1 ? GL_TRUE : GL_FALSE;
+ gui[1] = v & 2 ? GL_TRUE : GL_FALSE;
+ gui[2] = v & 4 ? GL_TRUE : GL_FALSE;
+ gui[3] = v & 8 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_INT: {
int v = value;
- GLint *gui = (GLint*)data;
- gui[0]=v;
+ GLint *gui = (GLint *)data;
+ gui[0] = v;
} break;
case ShaderLanguage::TYPE_IVEC2: {
PoolVector<int> iv = value;
int s = iv.size();
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<2;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 2; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
-
+ gui[i] = 0;
}
} break;
@@ -1937,387 +1828,372 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
PoolVector<int> iv = value;
int s = iv.size();
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<3;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 3; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
-
+ gui[i] = 0;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
-
PoolVector<int> iv = value;
int s = iv.size();
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<4;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 4; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
-
+ gui[i] = 0;
}
} break;
case ShaderLanguage::TYPE_UINT: {
int v = value;
- GLuint *gui = (GLuint*)data;
- gui[0]=v;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = v;
} break;
case ShaderLanguage::TYPE_UVEC2: {
PoolVector<int> iv = value;
int s = iv.size();
- GLuint *gui = (GLuint*)data;
+ GLuint *gui = (GLuint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<2;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 2; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
-
+ gui[i] = 0;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
PoolVector<int> iv = value;
int s = iv.size();
- GLuint *gui = (GLuint*)data;
+ GLuint *gui = (GLuint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<3;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 3; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
+ gui[i] = 0;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
PoolVector<int> iv = value;
int s = iv.size();
- GLuint *gui = (GLuint*)data;
+ GLuint *gui = (GLuint *)data;
PoolVector<int>::Read r = iv.read();
- for(int i=0;i<4;i++) {
- if (i<s)
- gui[i]=r[i];
+ for (int i = 0; i < 4; i++) {
+ if (i < s)
+ gui[i] = r[i];
else
- gui[i]=0;
+ gui[i] = 0;
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
float v = value;
- GLfloat *gui = (GLfloat*)data;
- gui[0]=v;
+ GLfloat *gui = (GLfloat *)data;
+ gui[0] = v;
} break;
case ShaderLanguage::TYPE_VEC2: {
Vector2 v = value;
- GLfloat *gui = (GLfloat*)data;
- gui[0]=v.x;
- gui[1]=v.y;
+ GLfloat *gui = (GLfloat *)data;
+ gui[0] = v.x;
+ gui[1] = v.y;
} break;
case ShaderLanguage::TYPE_VEC3: {
Vector3 v = value;
- GLfloat *gui = (GLfloat*)data;
- gui[0]=v.x;
- gui[1]=v.y;
- gui[2]=v.z;
+ GLfloat *gui = (GLfloat *)data;
+ gui[0] = v.x;
+ gui[1] = v.y;
+ gui[2] = v.z;
} break;
case ShaderLanguage::TYPE_VEC4: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- if (value.get_type()==Variant::COLOR) {
- Color v=value;
+ if (value.get_type() == Variant::COLOR) {
+ Color v = value;
if (p_linear_color) {
- v=v.to_linear();
+ v = v.to_linear();
}
- gui[0]=v.r;
- gui[1]=v.g;
- gui[2]=v.b;
- gui[3]=v.a;
- } else if (value.get_type()==Variant::RECT2) {
- Rect2 v=value;
+ gui[0] = v.r;
+ gui[1] = v.g;
+ gui[2] = v.b;
+ gui[3] = v.a;
+ } else if (value.get_type() == Variant::RECT2) {
+ Rect2 v = value;
- gui[0]=v.pos.x;
- gui[1]=v.pos.y;
- gui[2]=v.size.x;
- gui[3]=v.size.y;
- } else if (value.get_type()==Variant::QUAT) {
- Quat v=value;
+ gui[0] = v.pos.x;
+ gui[1] = v.pos.y;
+ gui[2] = v.size.x;
+ gui[3] = v.size.y;
+ } else if (value.get_type() == Variant::QUAT) {
+ Quat v = value;
- gui[0]=v.x;
- gui[1]=v.y;
- gui[2]=v.z;
- gui[3]=v.w;
+ gui[0] = v.x;
+ gui[1] = v.y;
+ gui[2] = v.z;
+ gui[3] = v.w;
} else {
- Plane v=value;
-
- gui[0]=v.normal.x;
- gui[1]=v.normal.y;
- gui[2]=v.normal.x;
- gui[3]=v.d;
+ Plane v = value;
+ gui[0] = v.normal.x;
+ gui[1] = v.normal.y;
+ gui[2] = v.normal.x;
+ gui[3] = v.d;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
Transform2D v = value;
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- gui[ 0]=v.elements[0][0];
- gui[ 1]=v.elements[0][1];
- gui[ 2]=v.elements[1][0];
- gui[ 3]=v.elements[1][1];
+ gui[0] = v.elements[0][0];
+ gui[1] = v.elements[0][1];
+ gui[2] = v.elements[1][0];
+ gui[3] = v.elements[1][1];
} break;
case ShaderLanguage::TYPE_MAT3: {
-
Basis v = value;
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- gui[ 0]=v.elements[0][0];
- gui[ 1]=v.elements[1][0];
- gui[ 2]=v.elements[2][0];
- gui[ 3]=0;
- gui[ 4]=v.elements[0][1];
- gui[ 5]=v.elements[1][1];
- gui[ 6]=v.elements[2][1];
- gui[ 7]=0;
- gui[ 8]=v.elements[0][2];
- gui[ 9]=v.elements[1][2];
- gui[10]=v.elements[2][2];
- gui[11]=0;
+ gui[0] = v.elements[0][0];
+ gui[1] = v.elements[1][0];
+ gui[2] = v.elements[2][0];
+ gui[3] = 0;
+ gui[4] = v.elements[0][1];
+ gui[5] = v.elements[1][1];
+ gui[6] = v.elements[2][1];
+ gui[7] = 0;
+ gui[8] = v.elements[0][2];
+ gui[9] = v.elements[1][2];
+ gui[10] = v.elements[2][2];
+ gui[11] = 0;
} break;
case ShaderLanguage::TYPE_MAT4: {
Transform v = value;
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- gui[ 0]=v.basis.elements[0][0];
- gui[ 1]=v.basis.elements[1][0];
- gui[ 2]=v.basis.elements[2][0];
- gui[ 3]=0;
- gui[ 4]=v.basis.elements[0][1];
- gui[ 5]=v.basis.elements[1][1];
- gui[ 6]=v.basis.elements[2][1];
- gui[ 7]=0;
- gui[ 8]=v.basis.elements[0][2];
- gui[ 9]=v.basis.elements[1][2];
- gui[10]=v.basis.elements[2][2];
- gui[11]=0;
- gui[12]=v.origin.x;
- gui[13]=v.origin.y;
- gui[14]=v.origin.z;
- gui[15]=1;
+ gui[0] = v.basis.elements[0][0];
+ gui[1] = v.basis.elements[1][0];
+ gui[2] = v.basis.elements[2][0];
+ gui[3] = 0;
+ gui[4] = v.basis.elements[0][1];
+ gui[5] = v.basis.elements[1][1];
+ gui[6] = v.basis.elements[2][1];
+ gui[7] = 0;
+ gui[8] = v.basis.elements[0][2];
+ gui[9] = v.basis.elements[1][2];
+ gui[10] = v.basis.elements[2][2];
+ gui[11] = 0;
+ gui[12] = v.origin.x;
+ gui[13] = v.origin.y;
+ gui[14] = v.origin.z;
+ gui[15] = 1;
} break;
default: {}
}
-
}
-_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value>& value, uint8_t *data) {
+_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value> &value, uint8_t *data) {
- switch(type) {
+ switch (type) {
case ShaderLanguage::TYPE_BOOL: {
- GLuint *gui = (GLuint*)data;
+ GLuint *gui = (GLuint *)data;
*gui = value[0].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC2: {
- GLuint *gui = (GLuint*)data;
- gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
- gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE;
+ gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC3: {
- GLuint *gui = (GLuint*)data;
- gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
- gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
- gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE;
+ gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE;
+ gui[2] = value[2].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC4: {
- GLuint *gui = (GLuint*)data;
- gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
- gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
- gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
- gui[3]=value[3].boolean ? GL_TRUE : GL_FALSE;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = value[0].boolean ? GL_TRUE : GL_FALSE;
+ gui[1] = value[1].boolean ? GL_TRUE : GL_FALSE;
+ gui[2] = value[2].boolean ? GL_TRUE : GL_FALSE;
+ gui[3] = value[3].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_INT: {
- GLint *gui = (GLint*)data;
- gui[0]=value[0].sint;
+ GLint *gui = (GLint *)data;
+ gui[0] = value[0].sint;
} break;
case ShaderLanguage::TYPE_IVEC2: {
- GLint *gui = (GLint*)data;
-
- for(int i=0;i<2;i++) {
- gui[i]=value[i].sint;
+ GLint *gui = (GLint *)data;
+ for (int i = 0; i < 2; i++) {
+ gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
- GLint *gui = (GLint*)data;
-
- for(int i=0;i<3;i++) {
- gui[i]=value[i].sint;
+ GLint *gui = (GLint *)data;
+ for (int i = 0; i < 3; i++) {
+ gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
- GLint *gui = (GLint*)data;
-
- for(int i=0;i<4;i++) {
- gui[i]=value[i].sint;
+ GLint *gui = (GLint *)data;
+ for (int i = 0; i < 4; i++) {
+ gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_UINT: {
-
- GLuint *gui = (GLuint*)data;
- gui[0]=value[0].uint;
+ GLuint *gui = (GLuint *)data;
+ gui[0] = value[0].uint;
} break;
case ShaderLanguage::TYPE_UVEC2: {
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
- for(int i=0;i<2;i++) {
- gui[i]=value[i].uint;
+ for (int i = 0; i < 2; i++) {
+ gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
- for(int i=0;i<3;i++) {
- gui[i]=value[i].uint;
+ for (int i = 0; i < 3; i++) {
+ gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
- GLint *gui = (GLint*)data;
+ GLint *gui = (GLint *)data;
- for(int i=0;i<4;i++) {
- gui[i]=value[i].uint;
+ for (int i = 0; i < 4; i++) {
+ gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
- GLfloat *gui = (GLfloat*)data;
- gui[0]=value[0].real;
+ GLfloat *gui = (GLfloat *)data;
+ gui[0] = value[0].real;
} break;
case ShaderLanguage::TYPE_VEC2: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- for(int i=0;i<2;i++) {
- gui[i]=value[i].real;
+ for (int i = 0; i < 2; i++) {
+ gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC3: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- for(int i=0;i<3;i++) {
- gui[i]=value[i].real;
+ for (int i = 0; i < 3; i++) {
+ gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC4: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- for(int i=0;i<4;i++) {
- gui[i]=value[i].real;
+ for (int i = 0; i < 4; i++) {
+ gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- for(int i=0;i<2;i++) {
- gui[i]=value[i].real;
+ for (int i = 0; i < 2; i++) {
+ gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_MAT3: {
+ GLfloat *gui = (GLfloat *)data;
-
- GLfloat *gui = (GLfloat*)data;
-
- gui[ 0]=value[0].real;
- gui[ 1]=value[1].real;
- gui[ 2]=value[2].real;
- gui[ 3]=0;
- gui[ 4]=value[3].real;
- gui[ 5]=value[4].real;
- gui[ 6]=value[5].real;
- gui[ 7]=0;
- gui[ 8]=value[6].real;
- gui[ 9]=value[7].real;
- gui[10]=value[8].real;
- gui[11]=0;
+ gui[0] = value[0].real;
+ gui[1] = value[1].real;
+ gui[2] = value[2].real;
+ gui[3] = 0;
+ gui[4] = value[3].real;
+ gui[5] = value[4].real;
+ gui[6] = value[5].real;
+ gui[7] = 0;
+ gui[8] = value[6].real;
+ gui[9] = value[7].real;
+ gui[10] = value[8].real;
+ gui[11] = 0;
} break;
case ShaderLanguage::TYPE_MAT4: {
- GLfloat *gui = (GLfloat*)data;
+ GLfloat *gui = (GLfloat *)data;
- for(int i=0;i<16;i++) {
- gui[i]=value[i].real;
+ for (int i = 0; i < 16; i++) {
+ gui[i] = value[i].real;
}
} break;
default: {}
}
-
}
-
_FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, uint8_t *data) {
- switch(type) {
+ switch (type) {
case ShaderLanguage::TYPE_BOOL:
case ShaderLanguage::TYPE_INT:
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_FLOAT: {
- zeromem(data,4);
+ zeromem(data, 4);
} break;
case ShaderLanguage::TYPE_BVEC2:
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_VEC2: {
- zeromem(data,8);
+ zeromem(data, 8);
} break;
case ShaderLanguage::TYPE_BVEC3:
case ShaderLanguage::TYPE_IVEC3:
@@ -2327,28 +2203,26 @@ _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type,
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC4:
case ShaderLanguage::TYPE_VEC4:
- case ShaderLanguage::TYPE_MAT2:{
+ case ShaderLanguage::TYPE_MAT2: {
- zeromem(data,16);
+ zeromem(data, 16);
} break;
- case ShaderLanguage::TYPE_MAT3:{
+ case ShaderLanguage::TYPE_MAT3: {
- zeromem(data,48);
+ zeromem(data, 48);
} break;
- case ShaderLanguage::TYPE_MAT4:{
- zeromem(data,64);
+ case ShaderLanguage::TYPE_MAT4: {
+ zeromem(data, 64);
} break;
default: {}
}
-
}
-void RasterizerStorageGLES3::_update_material(Material* material) {
+void RasterizerStorageGLES3::_update_material(Material *material) {
if (material->dirty_list.in_list())
- _material_dirty_list.remove( &material->dirty_list );
-
+ _material_dirty_list.remove(&material->dirty_list);
if (material->shader && material->shader->dirty_list.in_list()) {
_update_shader(material->shader);
@@ -2359,90 +2233,85 @@ void RasterizerStorageGLES3::_update_material(Material* material) {
bool can_cast_shadow = false;
bool is_animated = false;
- if (material->shader && material->shader->mode==VS::SHADER_SPATIAL) {
+ if (material->shader && material->shader->mode == VS::SHADER_SPATIAL) {
- if (!material->shader->spatial.uses_alpha && material->shader->spatial.blend_mode==Shader::Spatial::BLEND_MODE_MIX) {
- can_cast_shadow=true;
+ if (!material->shader->spatial.uses_alpha && material->shader->spatial.blend_mode == Shader::Spatial::BLEND_MODE_MIX) {
+ can_cast_shadow = true;
}
if (material->shader->spatial.uses_discard && material->shader->uses_fragment_time) {
- is_animated=true;
+ is_animated = true;
}
if (material->shader->spatial.uses_vertex && material->shader->uses_vertex_time) {
- is_animated=true;
+ is_animated = true;
}
- if (can_cast_shadow!=material->can_cast_shadow_cache || is_animated!=material->is_animated_cache) {
- material->can_cast_shadow_cache=can_cast_shadow;
- material->is_animated_cache=is_animated;
+ if (can_cast_shadow != material->can_cast_shadow_cache || is_animated != material->is_animated_cache) {
+ material->can_cast_shadow_cache = can_cast_shadow;
+ material->is_animated_cache = is_animated;
- for(Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
+ for (Map<Geometry *, int>::Element *E = material->geometry_owners.front(); E; E = E->next()) {
E->key()->material_changed_notify();
}
- for(Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
+ for (Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.front(); E; E = E->next()) {
E->key()->base_material_changed();
}
-
}
}
-
}
-
//clear ubo if it needs to be cleared
if (material->ubo_size) {
- if (!material->shader || material->shader->ubo_size!=material->ubo_size) {
+ if (!material->shader || material->shader->ubo_size != material->ubo_size) {
//by by ubo
- glDeleteBuffers(1,&material->ubo_id);
- material->ubo_id=0;
- material->ubo_size=0;
+ glDeleteBuffers(1, &material->ubo_id);
+ material->ubo_id = 0;
+ material->ubo_size = 0;
}
}
//create ubo if it needs to be created
- if (material->ubo_size==0 && material->shader && material->shader->ubo_size) {
+ if (material->ubo_size == 0 && material->shader && material->shader->ubo_size) {
glGenBuffers(1, &material->ubo_id);
glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id);
glBufferData(GL_UNIFORM_BUFFER, material->shader->ubo_size, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
- material->ubo_size=material->shader->ubo_size;
+ material->ubo_size = material->shader->ubo_size;
}
//fill up the UBO if it needs to be filled
if (material->shader && material->ubo_size) {
- uint8_t* local_ubo = (uint8_t*)alloca(material->ubo_size);
+ uint8_t *local_ubo = (uint8_t *)alloca(material->ubo_size);
- for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
+ for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = material->shader->uniforms.front(); E; E = E->next()) {
- if (E->get().order<0)
+ if (E->get().order < 0)
continue; // texture, does not go here
//regular uniform
- uint8_t *data = &local_ubo[ material->shader->ubo_offsets[E->get().order] ];
+ uint8_t *data = &local_ubo[material->shader->ubo_offsets[E->get().order]];
- Map<StringName,Variant>::Element *V = material->params.find(E->key());
+ Map<StringName, Variant>::Element *V = material->params.find(E->key());
if (V) {
- //user provided
- _fill_std140_variant_ubo_value(E->get().type,V->get(),data,material->shader->mode==VS::SHADER_SPATIAL);
+ //user provided
+ _fill_std140_variant_ubo_value(E->get().type, V->get(), data, material->shader->mode == VS::SHADER_SPATIAL);
- } else if (E->get().default_value.size()){
+ } else if (E->get().default_value.size()) {
//default value
- _fill_std140_ubo_value(E->get().type,E->get().default_value,data);
+ _fill_std140_ubo_value(E->get().type, E->get().default_value, data);
//value=E->get().default_value;
} else {
//zero because it was not provided
- _fill_std140_ubo_empty(E->get().type,data);
+ _fill_std140_ubo_empty(E->get().type, data);
}
-
-
}
- glBindBuffer(GL_UNIFORM_BUFFER,material->ubo_id);
+ glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id);
glBufferSubData(GL_UNIFORM_BUFFER, 0, material->ubo_size, local_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
@@ -2452,70 +2321,64 @@ void RasterizerStorageGLES3::_update_material(Material* material) {
material->textures.resize(material->shader->texture_count);
- for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
+ for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = material->shader->uniforms.front(); E; E = E->next()) {
- if (E->get().texture_order<0)
+ if (E->get().texture_order < 0)
continue; // not a texture, does not go here
RID texture;
- Map<StringName,Variant>::Element *V = material->params.find(E->key());
+ Map<StringName, Variant>::Element *V = material->params.find(E->key());
if (V) {
- texture=V->get();
+ texture = V->get();
}
if (!texture.is_valid()) {
- Map<StringName,RID>::Element *W = material->shader->default_textures.find(E->key());
+ Map<StringName, RID>::Element *W = material->shader->default_textures.find(E->key());
if (W) {
- texture=W->get();
+ texture = W->get();
}
}
- material->textures[ E->get().texture_order ]=texture;
-
-
+ material->textures[E->get().texture_order] = texture;
}
-
} else {
material->textures.clear();
}
-
}
-void RasterizerStorageGLES3::_material_add_geometry(RID p_material,Geometry *p_geometry) {
+void RasterizerStorageGLES3::_material_add_geometry(RID p_material, Geometry *p_geometry) {
- Material * material = material_owner.getornull(p_material);
+ Material *material = material_owner.getornull(p_material);
ERR_FAIL_COND(!material);
- Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
+ Map<Geometry *, int>::Element *I = material->geometry_owners.find(p_geometry);
if (I) {
I->get()++;
} else {
- material->geometry_owners[p_geometry]=1;
+ material->geometry_owners[p_geometry] = 1;
}
-
}
-void RasterizerStorageGLES3::_material_remove_geometry(RID p_material,Geometry *p_geometry) {
+void RasterizerStorageGLES3::_material_remove_geometry(RID p_material, Geometry *p_geometry) {
- Material * material = material_owner.getornull(p_material);
+ Material *material = material_owner.getornull(p_material);
ERR_FAIL_COND(!material);
- Map<Geometry*,int>::Element *I = material->geometry_owners.find(p_geometry);
+ Map<Geometry *, int>::Element *I = material->geometry_owners.find(p_geometry);
ERR_FAIL_COND(!I);
I->get()--;
- if (I->get()==0) {
+ if (I->get() == 0) {
material->geometry_owners.erase(I);
}
}
-
void RasterizerStorageGLES3::update_dirty_materials() {
- while( _material_dirty_list.first() ) {
+ while (_material_dirty_list.first()) {
Material *material = _material_dirty_list.first()->self();
@@ -2525,389 +2388,366 @@ void RasterizerStorageGLES3::update_dirty_materials() {
/* MESH API */
-RID RasterizerStorageGLES3::mesh_create(){
+RID RasterizerStorageGLES3::mesh_create() {
- Mesh * mesh = memnew( Mesh );
+ 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 PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes,const Vector<Rect3>& p_bone_aabbs){
-
+void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh, uint32_t p_format, VS::PrimitiveType p_primitive, const PoolVector<uint8_t> &p_array, int p_vertex_count, const PoolVector<uint8_t> &p_index_array, int p_index_count, const Rect3 &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes, const Vector<Rect3> &p_bone_aabbs) {
PoolVector<uint8_t> array = p_array;
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
- ERR_FAIL_COND(!(p_format&VS::ARRAY_FORMAT_VERTEX));
+ 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;
+ 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 );
+ 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];
- int stride=0;
+ int stride = 0;
- for(int i=0;i<VS::ARRAY_MAX;i++) {
+ for (int i = 0; i < VS::ARRAY_MAX; i++) {
- attribs[i].index=i;
+ attribs[i].index = i;
- if (! (p_format&(1<<i) ) ) {
- attribs[i].enabled=false;
- attribs[i].integer=false;
+ if (!(p_format & (1 << i))) {
+ attribs[i].enabled = false;
+ attribs[i].integer = false;
continue;
}
- attribs[i].enabled=true;
- attribs[i].offset=stride;
- attribs[i].integer=false;
+ attribs[i].enabled = true;
+ attribs[i].offset = stride;
+ attribs[i].integer = false;
- switch(i) {
+ switch (i) {
case VS::ARRAY_VERTEX: {
- if (p_format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
- attribs[i].size=2;
+ if (p_format & VS::ARRAY_FLAG_USE_2D_VERTICES) {
+ attribs[i].size = 2;
} else {
- attribs[i].size=(p_format&VS::ARRAY_COMPRESS_VERTEX)?4:3;
+ attribs[i].size = (p_format & VS::ARRAY_COMPRESS_VERTEX) ? 4 : 3;
}
- if (p_format&VS::ARRAY_COMPRESS_VERTEX) {
- attribs[i].type=GL_HALF_FLOAT;
- stride+=attribs[i].size*2;
+ 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].type = GL_FLOAT;
+ stride += attribs[i].size * 4;
}
- attribs[i].normalized=GL_FALSE;
+ attribs[i].normalized = GL_FALSE;
} break;
case VS::ARRAY_NORMAL: {
- attribs[i].size=3;
+ 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;
+ 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;
+ attribs[i].type = GL_FLOAT;
+ stride += 12;
+ attribs[i].normalized = GL_FALSE;
}
-
-
} break;
case VS::ARRAY_TANGENT: {
- attribs[i].size=4;
+ attribs[i].size = 4;
- if (p_format&VS::ARRAY_COMPRESS_TANGENT) {
- attribs[i].type=GL_BYTE;
- stride+=4;
- attribs[i].normalized=GL_TRUE;
+ 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;
+ attribs[i].type = GL_FLOAT;
+ stride += 16;
+ attribs[i].normalized = GL_FALSE;
}
-
} break;
case VS::ARRAY_COLOR: {
- attribs[i].size=4;
+ attribs[i].size = 4;
- if (p_format&VS::ARRAY_COMPRESS_COLOR) {
- attribs[i].type=GL_UNSIGNED_BYTE;
- stride+=4;
- attribs[i].normalized=GL_TRUE;
+ 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;
+ attribs[i].type = GL_FLOAT;
+ stride += 16;
+ attribs[i].normalized = GL_FALSE;
}
-
} break;
case VS::ARRAY_TEX_UV: {
- attribs[i].size=2;
+ attribs[i].size = 2;
- if (p_format&VS::ARRAY_COMPRESS_TEX_UV) {
- attribs[i].type=GL_HALF_FLOAT;
- stride+=4;
+ 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].type = GL_FLOAT;
+ stride += 8;
}
- attribs[i].normalized=GL_FALSE;
-
+ attribs[i].normalized = GL_FALSE;
} break;
case VS::ARRAY_TEX_UV2: {
- attribs[i].size=2;
+ attribs[i].size = 2;
- if (p_format&VS::ARRAY_COMPRESS_TEX_UV2) {
- attribs[i].type=GL_HALF_FLOAT;
- stride+=4;
+ 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].type = GL_FLOAT;
+ stride += 8;
}
- attribs[i].normalized=GL_FALSE;
-
-
+ attribs[i].normalized = GL_FALSE;
} break;
case VS::ARRAY_BONES: {
- attribs[i].size=4;
+ attribs[i].size = 4;
- if (p_format&VS::ARRAY_FLAG_USE_16_BIT_BONES) {
- attribs[i].type=GL_UNSIGNED_SHORT;
- stride+=8;
+ 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;
+ attribs[i].type = GL_UNSIGNED_BYTE;
+ stride += 4;
}
- attribs[i].normalized=GL_FALSE;
- attribs[i].integer=true;
-
-
+ attribs[i].normalized = GL_FALSE;
+ attribs[i].integer = true;
} break;
case VS::ARRAY_WEIGHTS: {
- attribs[i].size=4;
+ attribs[i].size = 4;
- if (p_format&VS::ARRAY_COMPRESS_WEIGHTS) {
+ if (p_format & VS::ARRAY_COMPRESS_WEIGHTS) {
- attribs[i].type=GL_UNSIGNED_SHORT;
- stride+=8;
- attribs[i].normalized=GL_TRUE;
+ 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;
+ attribs[i].type = GL_FLOAT;
+ stride += 16;
+ attribs[i].normalized = GL_FALSE;
}
} break;
case VS::ARRAY_INDEX: {
- attribs[i].size=1;
+ attribs[i].size = 1;
- if (p_vertex_count>=(1<<16)) {
- attribs[i].type=GL_UNSIGNED_INT;
- attribs[i].stride=4;
+ 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].type = GL_UNSIGNED_SHORT;
+ attribs[i].stride = 2;
}
- attribs[i].normalized=GL_FALSE;
+ attribs[i].normalized = GL_FALSE;
} break;
-
}
}
- for(int i=0;i<VS::ARRAY_MAX-1;i++) {
- attribs[i].stride=stride;
+ for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
+ attribs[i].stride = stride;
}
//validate sizes
int array_size = stride * p_vertex_count;
- int index_array_size=0;
- if (array.size()!=array_size && array.size()+p_vertex_count*2 == array_size) {
+ int index_array_size = 0;
+ if (array.size() != array_size && array.size() + p_vertex_count * 2 == array_size) {
//old format, convert
array = PoolVector<uint8_t>();
- array.resize( p_array.size()+p_vertex_count*2 );
+ array.resize(p_array.size() + p_vertex_count * 2);
PoolVector<uint8_t>::Write w = array.write();
PoolVector<uint8_t>::Read r = p_array.read();
- uint16_t *w16 = (uint16_t*)w.ptr();
- const uint16_t *r16 = (uint16_t*)r.ptr();
+ uint16_t *w16 = (uint16_t *)w.ptr();
+ const uint16_t *r16 = (uint16_t *)r.ptr();
uint16_t one = Math::make_half_float(1);
- for(int i=0;i<p_vertex_count;i++) {
+ for (int i = 0; i < p_vertex_count; i++) {
*w16++ = *r16++;
*w16++ = *r16++;
*w16++ = *r16++;
*w16++ = one;
- for(int j=0;j<(stride/2)-4;j++) {
+ for (int j = 0; j < (stride / 2) - 4; j++) {
*w16++ = *r16++;
}
}
-
}
- ERR_FAIL_COND(array.size()!=array_size);
+ ERR_FAIL_COND(array.size() != array_size);
- if (p_format&VS::ARRAY_FORMAT_INDEX) {
+ if (p_format & VS::ARRAY_FORMAT_INDEX) {
- index_array_size=attribs[VS::ARRAY_INDEX].stride*p_index_count;
+ index_array_size = attribs[VS::ARRAY_INDEX].stride * p_index_count;
}
+ ERR_FAIL_COND(p_index_array.size() != index_array_size);
- ERR_FAIL_COND(p_index_array.size()!=index_array_size);
+ ERR_FAIL_COND(p_blend_shapes.size() != mesh->blend_shape_count);
- ERR_FAIL_COND(p_blend_shapes.size()!=mesh->blend_shape_count);
-
- for(int i=0;i<p_blend_shapes.size();i++) {
- ERR_FAIL_COND(p_blend_shapes[i].size()!=array_size);
+ 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 *surface = memnew(Surface);
- surface->active=true;
- surface->array_len=p_vertex_count;
- surface->index_array_len=p_index_count;
- surface->array_byte_size=array.size();
- surface->index_array_byte_size=p_index_array.size();
- surface->primitive=p_primitive;
- surface->mesh=mesh;
- surface->format=p_format;
- surface->skeleton_bone_aabb=p_bone_aabbs;
+ surface->active = true;
+ surface->array_len = p_vertex_count;
+ surface->index_array_len = p_index_count;
+ surface->array_byte_size = array.size();
+ surface->index_array_byte_size = p_index_array.size();
+ 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();
+ 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;
+ 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;
+ surface->skeleton_bone_used[i] = true;
}
}
- for(int i=0;i<VS::ARRAY_MAX;i++) {
- surface->attribs[i]=attribs[i];
+ for (int i = 0; i < VS::ARRAY_MAX; i++) {
+ surface->attribs[i] = attribs[i];
}
{
PoolVector<uint8_t>::Read vr = 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
-
+ 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) {
+ if (p_format & VS::ARRAY_FORMAT_INDEX) {
PoolVector<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
-
-
+ 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
- for(int ai=0;ai<2;ai++) {
+ for (int ai = 0; ai < 2; ai++) {
- if (ai==0) {
+ if (ai == 0) {
//for normal draw
- glGenVertexArrays(1,&surface->array_id);
+ glGenVertexArrays(1, &surface->array_id);
glBindVertexArray(surface->array_id);
- glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
- } else if (ai==1) {
+ glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id);
+ } else if (ai == 1) {
//for instancing draw (can be changed and no one cares)
- glGenVertexArrays(1,&surface->instancing_array_id);
+ glGenVertexArrays(1, &surface->instancing_array_id);
glBindVertexArray(surface->instancing_array_id);
- glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
+ glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id);
}
-
- for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+ for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
if (!attribs[i].enabled)
continue;
if (attribs[i].integer) {
- glVertexAttribIPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+ glVertexAttribIPointer(attribs[i].index, attribs[i].size, attribs[i].type, attribs[i].stride, ((uint8_t *)0) + attribs[i].offset);
} else {
- glVertexAttribPointer(attribs[i].index,attribs[i].size,attribs[i].type,attribs[i].normalized,attribs[i].stride,((uint8_t*)0)+attribs[i].offset);
+ 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);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, surface->index_id);
}
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
-
}
{
//blend shapes
- for(int i=0;i<p_blend_shapes.size();i++) {
+ for (int i = 0; i < p_blend_shapes.size(); i++) {
Surface::BlendShape mt;
PoolVector<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
+ 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);
+ glGenVertexArrays(1, &mt.array_id);
glBindVertexArray(mt.array_id);
- glBindBuffer(GL_ARRAY_BUFFER,mt.vertex_id);
+ glBindBuffer(GL_ARRAY_BUFFER, mt.vertex_id);
- for(int j=0;j<VS::ARRAY_MAX-1;j++) {
+ for (int j = 0; j < VS::ARRAY_MAX - 1; j++) {
if (!attribs[j].enabled)
continue;
if (attribs[j].integer) {
- glVertexAttribIPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
+ glVertexAttribIPointer(attribs[j].index, attribs[j].size, attribs[j].type, attribs[j].stride, ((uint8_t *)0) + attribs[j].offset);
} else {
- glVertexAttribPointer(attribs[j].index,attribs[j].size,attribs[j].type,attribs[j].normalized,attribs[j].stride,((uint8_t*)0)+attribs[j].offset);
+ glVertexAttribPointer(attribs[j].index, attribs[j].size, attribs[j].type, attribs[j].normalized, attribs[j].stride, ((uint8_t *)0) + attribs[j].offset);
}
glEnableVertexAttribArray(attribs[j].index);
-
}
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
surface->blend_shapes.push_back(mt);
-
}
}
@@ -2915,105 +2755,98 @@ void RasterizerStorageGLES3::mesh_add_surface(RID p_mesh,uint32_t p_format,VS::P
mesh->instance_change_notify();
}
-void RasterizerStorageGLES3::mesh_set_blend_shape_count(RID p_mesh,int p_amount){
+void RasterizerStorageGLES3::mesh_set_blend_shape_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);
- ERR_FAIL_COND(mesh->surfaces.size()!=0);
- ERR_FAIL_COND(p_amount<0);
-
- mesh->blend_shape_count=p_amount;
-
+ mesh->blend_shape_count = p_amount;
}
-int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const{
+int RasterizerStorageGLES3::mesh_get_blend_shape_count(RID p_mesh) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,0);
+ ERR_FAIL_COND_V(!mesh, 0);
return mesh->blend_shape_count;
}
-
-void RasterizerStorageGLES3::mesh_set_blend_shape_mode(RID p_mesh,VS::BlendShapeMode p_mode){
+void RasterizerStorageGLES3::mesh_set_blend_shape_mode(RID p_mesh, VS::BlendShapeMode p_mode) {
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
- mesh->blend_shape_mode=p_mode;
-
+ mesh->blend_shape_mode = p_mode;
}
-VS::BlendShapeMode RasterizerStorageGLES3::mesh_get_blend_shape_mode(RID p_mesh) const{
+VS::BlendShapeMode RasterizerStorageGLES3::mesh_get_blend_shape_mode(RID p_mesh) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,VS::BLEND_SHAPE_MODE_NORMALIZED);
+ ERR_FAIL_COND_V(!mesh, VS::BLEND_SHAPE_MODE_NORMALIZED);
return mesh->blend_shape_mode;
}
-void RasterizerStorageGLES3::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material){
+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());
+ ERR_FAIL_INDEX(p_surface, mesh->surfaces.size());
- if (mesh->surfaces[p_surface]->material==p_material)
+ if (mesh->surfaces[p_surface]->material == p_material)
return;
if (mesh->surfaces[p_surface]->material.is_valid()) {
- _material_remove_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
+ _material_remove_geometry(mesh->surfaces[p_surface]->material, mesh->surfaces[p_surface]);
}
- mesh->surfaces[p_surface]->material=p_material;
+ mesh->surfaces[p_surface]->material = p_material;
if (mesh->surfaces[p_surface]->material.is_valid()) {
- _material_add_geometry(mesh->surfaces[p_surface]->material,mesh->surfaces[p_surface]);
+ _material_add_geometry(mesh->surfaces[p_surface]->material, mesh->surfaces[p_surface]);
}
mesh->instance_material_change_notify();
-
-
}
-RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const{
+RID RasterizerStorageGLES3::mesh_surface_get_material(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,RID());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),RID());
+ 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{
+int RasterizerStorageGLES3::mesh_surface_get_array_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);
+ 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{
+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);
+ ERR_FAIL_COND_V(!mesh, 0);
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), 0);
return mesh->surfaces[p_surface]->index_array_len;
}
-PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const{
+PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,PoolVector<uint8_t>());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
+ ERR_FAIL_COND_V(!mesh, PoolVector<uint8_t>());
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), PoolVector<uint8_t>());
Surface *surface = mesh->surfaces[p_surface];
- glBindBuffer(GL_ARRAY_BUFFER,surface->vertex_id);
- void * data = glMapBufferRange(GL_ARRAY_BUFFER,0,surface->array_byte_size,GL_MAP_READ_BIT);
+ glBindBuffer(GL_ARRAY_BUFFER, surface->vertex_id);
+ void *data = glMapBufferRange(GL_ARRAY_BUFFER, 0, surface->array_byte_size, GL_MAP_READ_BIT);
- ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
+ ERR_FAIL_COND_V(!data, PoolVector<uint8_t>());
PoolVector<uint8_t> ret;
ret.resize(surface->array_byte_size);
@@ -3021,27 +2854,26 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_array(RID p_mesh, i
{
PoolVector<uint8_t>::Write w = ret.write();
- copymem(w.ptr(),data,surface->array_byte_size);
+ copymem(w.ptr(), data, surface->array_byte_size);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
-
return ret;
}
PoolVector<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,PoolVector<uint8_t>());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),PoolVector<uint8_t>());
+ ERR_FAIL_COND_V(!mesh, PoolVector<uint8_t>());
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), PoolVector<uint8_t>());
Surface *surface = mesh->surfaces[p_surface];
- ERR_FAIL_COND_V(surface->index_array_len==0,PoolVector<uint8_t>());
+ ERR_FAIL_COND_V(surface->index_array_len == 0, PoolVector<uint8_t>());
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,surface->index_id);
- void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,surface->index_array_byte_size,GL_MAP_READ_BIT);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, surface->index_id);
+ void *data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, surface->index_array_byte_size, GL_MAP_READ_BIT);
- ERR_FAIL_COND_V(!data,PoolVector<uint8_t>());
+ ERR_FAIL_COND_V(!data, PoolVector<uint8_t>());
PoolVector<uint8_t> ret;
ret.resize(surface->index_array_byte_size);
@@ -3049,7 +2881,7 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_m
{
PoolVector<uint8_t>::Write w = ret.write();
- copymem(w.ptr(),data,surface->index_array_byte_size);
+ copymem(w.ptr(), data, surface->index_array_byte_size);
}
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
@@ -3057,23 +2889,21 @@ PoolVector<uint8_t> RasterizerStorageGLES3::mesh_surface_get_index_array(RID p_m
return ret;
}
-
-uint32_t RasterizerStorageGLES3::mesh_surface_get_format(RID p_mesh, int p_surface) const{
+uint32_t RasterizerStorageGLES3::mesh_surface_get_format(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);
+ 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{
+VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_mesh, int p_surface) const {
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);
+ 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;
}
@@ -3081,27 +2911,25 @@ VS::PrimitiveType RasterizerStorageGLES3::mesh_surface_get_primitive_type(RID p_
Rect3 RasterizerStorageGLES3::mesh_surface_get_aabb(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,Rect3());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Rect3());
+ ERR_FAIL_COND_V(!mesh, Rect3());
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Rect3());
return mesh->surfaces[p_surface]->aabb;
-
-
}
-Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const{
+Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shapes(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,Vector<PoolVector<uint8_t> >());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<PoolVector<uint8_t> >());
+ ERR_FAIL_COND_V(!mesh, Vector<PoolVector<uint8_t> >());
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Vector<PoolVector<uint8_t> >());
Vector<PoolVector<uint8_t> > bsarr;
- for(int i=0;i<mesh->surfaces[p_surface]->blend_shapes.size();i++) {
+ for (int i = 0; i < mesh->surfaces[p_surface]->blend_shapes.size(); i++) {
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mesh->surfaces[p_surface]->blend_shapes[i].vertex_id);
- void * data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER,0,mesh->surfaces[p_surface]->array_byte_size,GL_MAP_READ_BIT);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->surfaces[p_surface]->blend_shapes[i].vertex_id);
+ void *data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, mesh->surfaces[p_surface]->array_byte_size, GL_MAP_READ_BIT);
- ERR_FAIL_COND_V(!data,Vector<PoolVector<uint8_t> >());
+ ERR_FAIL_COND_V(!data, Vector<PoolVector<uint8_t> >());
PoolVector<uint8_t> ret;
ret.resize(mesh->surfaces[p_surface]->array_byte_size);
@@ -3109,7 +2937,7 @@ Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shap
{
PoolVector<uint8_t>::Write w = ret.write();
- copymem(w.ptr(),data,mesh->surfaces[p_surface]->array_byte_size);
+ copymem(w.ptr(), data, mesh->surfaces[p_surface]->array_byte_size);
}
bsarr.push_back(ret);
@@ -3118,42 +2946,39 @@ Vector<PoolVector<uint8_t> > RasterizerStorageGLES3::mesh_surface_get_blend_shap
}
return bsarr;
-
}
-Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const{
+Vector<Rect3> RasterizerStorageGLES3::mesh_surface_get_skeleton_aabb(RID p_mesh, int p_surface) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,Vector<Rect3 >());
- ERR_FAIL_INDEX_V(p_surface,mesh->surfaces.size(),Vector<Rect3 >());
+ ERR_FAIL_COND_V(!mesh, Vector<Rect3>());
+ ERR_FAIL_INDEX_V(p_surface, mesh->surfaces.size(), Vector<Rect3>());
return mesh->surfaces[p_surface]->skeleton_bone_aabb;
-
}
-
-void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){
+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());
+ ERR_FAIL_INDEX(p_surface, mesh->surfaces.size());
Surface *surface = mesh->surfaces[p_surface];
if (surface->material.is_valid()) {
- _material_remove_geometry(surface->material,mesh->surfaces[p_surface]);
+ _material_remove_geometry(surface->material, mesh->surfaces[p_surface]);
}
- glDeleteBuffers(1,&surface->vertex_id);
+ glDeleteBuffers(1, &surface->vertex_id);
if (surface->index_id) {
- glDeleteBuffers(1,&surface->index_id);
+ glDeleteBuffers(1, &surface->index_id);
}
- glDeleteVertexArrays(1,&surface->array_id);
+ glDeleteVertexArrays(1, &surface->array_id);
- for(int i=0;i<surface->blend_shapes.size();i++) {
+ for (int i = 0; i < surface->blend_shapes.size(); i++) {
- glDeleteBuffers(1,&surface->blend_shapes[i].vertex_id);
- glDeleteVertexArrays(1,&surface->blend_shapes[i].array_id);
+ glDeleteBuffers(1, &surface->blend_shapes[i].vertex_id);
+ glDeleteVertexArrays(1, &surface->blend_shapes[i].array_id);
}
mesh->instance_material_change_notify();
@@ -3164,115 +2989,109 @@ void RasterizerStorageGLES3::mesh_remove_surface(RID p_mesh, int p_surface){
mesh->instance_change_notify();
}
-int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const{
+int RasterizerStorageGLES3::mesh_get_surface_count(RID p_mesh) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,0);
+ ERR_FAIL_COND_V(!mesh, 0);
return mesh->surfaces.size();
-
}
-void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh,const Rect3& p_aabb){
+void RasterizerStorageGLES3::mesh_set_custom_aabb(RID p_mesh, const Rect3 &p_aabb) {
Mesh *mesh = mesh_owner.getornull(p_mesh);
ERR_FAIL_COND(!mesh);
- mesh->custom_aabb=p_aabb;
+ mesh->custom_aabb = p_aabb;
}
-Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const{
+Rect3 RasterizerStorageGLES3::mesh_get_custom_aabb(RID p_mesh) const {
const Mesh *mesh = mesh_owner.getornull(p_mesh);
- ERR_FAIL_COND_V(!mesh,Rect3());
+ ERR_FAIL_COND_V(!mesh, Rect3());
return mesh->custom_aabb;
-
}
-Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
+Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh, RID p_skeleton) const {
- Mesh *mesh = mesh_owner.get( p_mesh );
- ERR_FAIL_COND_V(!mesh,Rect3());
+ Mesh *mesh = mesh_owner.get(p_mesh);
+ ERR_FAIL_COND_V(!mesh, Rect3());
- if (mesh->custom_aabb!=Rect3())
+ if (mesh->custom_aabb != Rect3())
return mesh->custom_aabb;
- Skeleton *sk=NULL;
+ Skeleton *sk = NULL;
if (p_skeleton.is_valid())
- sk=skeleton_owner.get(p_skeleton);
+ sk = skeleton_owner.get(p_skeleton);
Rect3 aabb;
- if (sk && sk->size!=0) {
+ if (sk && sk->size != 0) {
-
- for (int i=0;i<mesh->surfaces.size();i++) {
+ for (int i = 0; i < mesh->surfaces.size(); i++) {
Rect3 laabb;
- if (mesh->surfaces[i]->format&VS::ARRAY_FORMAT_BONES && mesh->surfaces[i]->skeleton_bone_aabb.size()) {
-
+ 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 Rect3 *skbones = mesh->surfaces[i]->skeleton_bone_aabb.ptr();
const bool *skused = mesh->surfaces[i]->skeleton_bone_used.ptr();
int sbs = sk->size;
- ERR_CONTINUE(bs>sbs);
+ ERR_CONTINUE(bs > sbs);
float *skb = sk->bones.ptr();
-
-
- bool first=true;
+ bool first = true;
if (sk->use_2d) {
- for(int j=0;j<bs;j++) {
+ for (int j = 0; j < bs; j++) {
if (!skused[j])
continue;
- float *dataptr = &skb[8*j];
+ float *dataptr = &skb[8 * j];
Transform mtx;
- mtx.basis.elements[0][0]=dataptr[ 0];
- mtx.basis.elements[0][1]=dataptr[ 1];
- mtx.origin[0]=dataptr[ 3];
- mtx.basis.elements[1][0]=dataptr[ 4];
- mtx.basis.elements[1][1]=dataptr[ 5];
- mtx.origin[1]=dataptr[ 7];
+ mtx.basis.elements[0][0] = dataptr[0];
+ mtx.basis.elements[0][1] = dataptr[1];
+ mtx.origin[0] = dataptr[3];
+ mtx.basis.elements[1][0] = dataptr[4];
+ mtx.basis.elements[1][1] = dataptr[5];
+ mtx.origin[1] = dataptr[7];
- Rect3 baabb = mtx.xform( skbones[j] );
+ Rect3 baabb = mtx.xform(skbones[j]);
if (first) {
- laabb=baabb;
- first=false;
+ laabb = baabb;
+ first = false;
} else {
laabb.merge_with(baabb);
}
}
} else {
- for(int j=0;j<bs;j++) {
+ for (int j = 0; j < bs; j++) {
if (!skused[j])
continue;
- float *dataptr = &skb[12*j];
+ float *dataptr = &skb[12 * j];
Transform mtx;
- mtx.basis.elements[0][0]=dataptr[ 0];
- mtx.basis.elements[0][1]=dataptr[ 1];
- mtx.basis.elements[0][2]=dataptr[ 2];
- mtx.origin.x=dataptr[ 3];
- mtx.basis.elements[1][0]=dataptr[ 4];
- mtx.basis.elements[1][1]=dataptr[ 5];
- mtx.basis.elements[1][2]=dataptr[ 6];
- mtx.origin.y=dataptr[ 7];
- mtx.basis.elements[2][0]=dataptr[ 8];
- mtx.basis.elements[2][1]=dataptr[ 9];
- mtx.basis.elements[2][2]=dataptr[10];
- mtx.origin.z=dataptr[11];
+ mtx.basis.elements[0][0] = dataptr[0];
+ mtx.basis.elements[0][1] = dataptr[1];
+ mtx.basis.elements[0][2] = dataptr[2];
+ mtx.origin.x = dataptr[3];
+ mtx.basis.elements[1][0] = dataptr[4];
+ mtx.basis.elements[1][1] = dataptr[5];
+ mtx.basis.elements[1][2] = dataptr[6];
+ mtx.origin.y = dataptr[7];
+ mtx.basis.elements[2][0] = dataptr[8];
+ mtx.basis.elements[2][1] = dataptr[9];
+ mtx.basis.elements[2][2] = dataptr[10];
+ mtx.origin.z = dataptr[11];
- Rect3 baabb = mtx.xform ( skbones[j] );
+ Rect3 baabb = mtx.xform(skbones[j]);
if (first) {
- laabb=baabb;
- first=false;
+ laabb = baabb;
+ first = false;
} else {
laabb.merge_with(baabb);
}
@@ -3281,36 +3100,34 @@ Rect3 RasterizerStorageGLES3::mesh_get_aabb(RID p_mesh,RID p_skeleton) const{
} else {
- laabb=mesh->surfaces[i]->aabb;
+ laabb = mesh->surfaces[i]->aabb;
}
- if (i==0)
- aabb=laabb;
+ if (i == 0)
+ aabb = laabb;
else
aabb.merge_with(laabb);
}
} else {
- for (int i=0;i<mesh->surfaces.size();i++) {
+ for (int i = 0; i < mesh->surfaces.size(); i++) {
- if (i==0)
- aabb=mesh->surfaces[i]->aabb;
+ if (i == 0)
+ aabb = mesh->surfaces[i]->aabb;
else
aabb.merge_with(mesh->surfaces[i]->aabb);
}
-
}
return aabb;
-
}
-void RasterizerStorageGLES3::mesh_clear(RID p_mesh){
+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);
+ while (mesh->surfaces.size()) {
+ mesh_remove_surface(p_mesh, 0);
}
}
@@ -3318,7 +3135,7 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh
glBindVertexArray(s->array_id);
- BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX-1]={
+ BlendShapeShaderGLES3::Conditionals cond[VS::ARRAY_MAX - 1] = {
BlendShapeShaderGLES3::ENABLE_NORMAL, //will be ignored
BlendShapeShaderGLES3::ENABLE_NORMAL,
BlendShapeShaderGLES3::ENABLE_TANGENT,
@@ -3329,197 +3146,190 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh
BlendShapeShaderGLES3::ENABLE_SKELETON,
};
- int stride=0;
+ int stride = 0;
- if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
- stride=2*4;
+ if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) {
+ stride = 2 * 4;
} else {
- stride=3*4;
+ stride = 3 * 4;
}
- static const int sizes[VS::ARRAY_MAX-1]={
- 3*4,
- 3*4,
- 4*4,
- 4*4,
- 2*4,
- 2*4,
- 4*4,
- 4*4
+ static const int sizes[VS::ARRAY_MAX - 1] = {
+ 3 * 4,
+ 3 * 4,
+ 4 * 4,
+ 4 * 4,
+ 2 * 4,
+ 2 * 4,
+ 4 * 4,
+ 4 * 4
};
- for(int i=1;i<VS::ARRAY_MAX-1;i++) {
- shaders.blend_shapes.set_conditional(cond[i],s->format&(1<<i)); //enable conditional for format
- if (s->format&(1<<i)) {
- stride+=sizes[i];
+ for (int i = 1; i < VS::ARRAY_MAX - 1; i++) {
+ shaders.blend_shapes.set_conditional(cond[i], s->format & (1 << i)); //enable conditional for format
+ if (s->format & (1 << i)) {
+ stride += sizes[i];
}
}
-
//copy all first
- float base_weight=1.0;
+ float base_weight = 1.0;
int mtc = s->blend_shapes.size();
- if (s->mesh->blend_shape_mode==VS::BLEND_SHAPE_MODE_NORMALIZED) {
+ if (s->mesh->blend_shape_mode == VS::BLEND_SHAPE_MODE_NORMALIZED) {
- for(int i=0;i<mtc;i++) {
- base_weight-=p_weights[i];
+ for (int i = 0; i < mtc; i++) {
+ base_weight -= p_weights[i];
}
}
-
-
- shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,false); //first pass does not blend
- shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::USE_2D_VERTEX,s->format&VS::ARRAY_FLAG_USE_2D_VERTICES); //use 2D vertices if needed
+ shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND, false); //first pass does not blend
+ shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::USE_2D_VERTEX, s->format & VS::ARRAY_FLAG_USE_2D_VERTICES); //use 2D vertices if needed
shaders.blend_shapes.bind();
- shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,base_weight);
+ shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT, base_weight);
glEnable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[0]);
glBeginTransformFeedback(GL_POINTS);
- glDrawArrays(GL_POINTS,0,s->array_len);
+ glDrawArrays(GL_POINTS, 0, s->array_len);
glEndTransformFeedback();
-
- shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND,true); //first pass does not blend
+ shaders.blend_shapes.set_conditional(BlendShapeShaderGLES3::ENABLE_BLEND, true); //first pass does not blend
shaders.blend_shapes.bind();
- for(int ti=0;ti<mtc;ti++) {
+ for (int ti = 0; ti < mtc; ti++) {
float weight = p_weights[ti];
- if (weight<0.001) //not bother with this one
+ if (weight < 0.001) //not bother with this one
continue;
glBindVertexArray(s->blend_shapes[ti].array_id);
glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, resources.transform_feedback_buffers[1]);
- shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT,weight);
+ shaders.blend_shapes.set_uniform(BlendShapeShaderGLES3::BLEND_AMOUNT, weight);
- int ofs=0;
- for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+ int ofs = 0;
+ for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
- if (s->format&(1<<i)) {
- glEnableVertexAttribArray(i+8);
- switch(i) {
+ if (s->format & (1 << i)) {
+ glEnableVertexAttribArray(i + 8);
+ switch (i) {
case VS::ARRAY_VERTEX: {
- if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
- glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) {
+ glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} else {
- glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=3*4;
+ glVertexAttribPointer(i + 8, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 3 * 4;
}
} break;
case VS::ARRAY_NORMAL: {
- glVertexAttribPointer(i+8,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=3*4;
+ glVertexAttribPointer(i + 8, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 3 * 4;
} break;
case VS::ARRAY_TANGENT: {
- glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_COLOR: {
- glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_TEX_UV: {
- glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} break;
case VS::ARRAY_TEX_UV2: {
- glVertexAttribPointer(i+8,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ glVertexAttribPointer(i + 8, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} break;
case VS::ARRAY_BONES: {
- glVertexAttribIPointer(i+8,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribIPointer(i + 8, 4, GL_UNSIGNED_INT, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_WEIGHTS: {
- glVertexAttribPointer(i+8,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i + 8, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
}
} else {
- glDisableVertexAttribArray(i+8);
+ glDisableVertexAttribArray(i + 8);
}
}
glBeginTransformFeedback(GL_POINTS);
- glDrawArrays(GL_POINTS,0,s->array_len);
+ glDrawArrays(GL_POINTS, 0, s->array_len);
glEndTransformFeedback();
-
- SWAP(resources.transform_feedback_buffers[0],resources.transform_feedback_buffers[1]);
-
+ SWAP(resources.transform_feedback_buffers[0], resources.transform_feedback_buffers[1]);
}
glDisable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
-
glBindVertexArray(resources.transform_feedback_array);
glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[0]);
- int ofs=0;
- for(int i=0;i<VS::ARRAY_MAX-1;i++) {
+ int ofs = 0;
+ for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
- if (s->format&(1<<i)) {
+ if (s->format & (1 << i)) {
glEnableVertexAttribArray(i);
- switch(i) {
+ switch (i) {
case VS::ARRAY_VERTEX: {
- if (s->format&VS::ARRAY_FLAG_USE_2D_VERTICES) {
- glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ if (s->format & VS::ARRAY_FLAG_USE_2D_VERTICES) {
+ glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} else {
- glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=3*4;
+ glVertexAttribPointer(i, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 3 * 4;
}
} break;
case VS::ARRAY_NORMAL: {
- glVertexAttribPointer(i,3,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=3*4;
+ glVertexAttribPointer(i, 3, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 3 * 4;
} break;
case VS::ARRAY_TANGENT: {
- glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_COLOR: {
- glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_TEX_UV: {
- glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} break;
case VS::ARRAY_TEX_UV2: {
- glVertexAttribPointer(i,2,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=2*4;
+ glVertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 2 * 4;
} break;
case VS::ARRAY_BONES: {
- glVertexAttribIPointer(i,4,GL_UNSIGNED_INT,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribIPointer(i, 4, GL_UNSIGNED_INT, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
case VS::ARRAY_WEIGHTS: {
- glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,stride,((uint8_t*)0)+ofs);
- ofs+=4*4;
+ glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, stride, ((uint8_t *)0) + ofs);
+ ofs += 4 * 4;
} break;
}
@@ -3530,131 +3340,126 @@ void RasterizerStorageGLES3::mesh_render_blend_shapes(Surface *s, float *p_weigh
}
if (s->index_array_len) {
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,s->index_id);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->index_id);
}
-
}
/* MULTIMESH API */
+RID RasterizerStorageGLES3::multimesh_create() {
-RID RasterizerStorageGLES3::multimesh_create(){
-
- MultiMesh *multimesh = memnew( MultiMesh );
+ MultiMesh *multimesh = memnew(MultiMesh);
return multimesh_owner.make_rid(multimesh);
}
-void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format){
+void RasterizerStorageGLES3::multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
- if (multimesh->size==p_instances && multimesh->transform_format==p_transform_format && multimesh->color_format==p_color_format)
+ if (multimesh->size == p_instances && multimesh->transform_format == p_transform_format && multimesh->color_format == p_color_format)
return;
if (multimesh->buffer) {
- glDeleteBuffers(1,&multimesh->buffer);
+ glDeleteBuffers(1, &multimesh->buffer);
multimesh->data.resize(0);
}
- multimesh->size=p_instances;
- multimesh->transform_format=p_transform_format;
- multimesh->color_format=p_color_format;
+ multimesh->size = p_instances;
+ multimesh->transform_format = p_transform_format;
+ multimesh->color_format = p_color_format;
if (multimesh->size) {
- if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
- multimesh->xform_floats=8;
+ if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) {
+ multimesh->xform_floats = 8;
} else {
- multimesh->xform_floats=12;
-
+ multimesh->xform_floats = 12;
}
- if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) {
- multimesh->color_floats=0;
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
- multimesh->color_floats=1;
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
- multimesh->color_floats=4;
+ if (multimesh->color_format == VS::MULTIMESH_COLOR_NONE) {
+ multimesh->color_floats = 0;
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) {
+ multimesh->color_floats = 1;
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) {
+ multimesh->color_floats = 4;
}
- int format_floats = multimesh->color_floats+multimesh->xform_floats;
- multimesh->data.resize(format_floats*p_instances);
- for(int i=0;i<p_instances;i+=format_floats) {
+ int format_floats = multimesh->color_floats + multimesh->xform_floats;
+ multimesh->data.resize(format_floats * p_instances);
+ for (int i = 0; i < p_instances; i += format_floats) {
- int color_from=0;
+ int color_from = 0;
- if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
- multimesh->data[i+0]=1.0;
- multimesh->data[i+1]=0.0;
- multimesh->data[i+2]=0.0;
- multimesh->data[i+3]=0.0;
- multimesh->data[i+4]=0.0;
- multimesh->data[i+5]=1.0;
- multimesh->data[i+6]=0.0;
- multimesh->data[i+7]=0.0;
- color_from=8;
+ if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) {
+ multimesh->data[i + 0] = 1.0;
+ multimesh->data[i + 1] = 0.0;
+ multimesh->data[i + 2] = 0.0;
+ multimesh->data[i + 3] = 0.0;
+ multimesh->data[i + 4] = 0.0;
+ multimesh->data[i + 5] = 1.0;
+ multimesh->data[i + 6] = 0.0;
+ multimesh->data[i + 7] = 0.0;
+ color_from = 8;
} else {
- multimesh->data[i+0]=1.0;
- multimesh->data[i+1]=0.0;
- multimesh->data[i+2]=0.0;
- multimesh->data[i+3]=0.0;
- multimesh->data[i+4]=0.0;
- multimesh->data[i+5]=1.0;
- multimesh->data[i+6]=0.0;
- multimesh->data[i+7]=0.0;
- multimesh->data[i+8]=0.0;
- multimesh->data[i+9]=0.0;
- multimesh->data[i+10]=1.0;
- multimesh->data[i+11]=0.0;
- color_from=12;
+ multimesh->data[i + 0] = 1.0;
+ multimesh->data[i + 1] = 0.0;
+ multimesh->data[i + 2] = 0.0;
+ multimesh->data[i + 3] = 0.0;
+ multimesh->data[i + 4] = 0.0;
+ multimesh->data[i + 5] = 1.0;
+ multimesh->data[i + 6] = 0.0;
+ multimesh->data[i + 7] = 0.0;
+ multimesh->data[i + 8] = 0.0;
+ multimesh->data[i + 9] = 0.0;
+ multimesh->data[i + 10] = 1.0;
+ multimesh->data[i + 11] = 0.0;
+ color_from = 12;
}
- if (multimesh->color_format==VS::MULTIMESH_COLOR_NONE) {
+ if (multimesh->color_format == VS::MULTIMESH_COLOR_NONE) {
//none
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) {
union {
uint32_t colu;
float colf;
} cu;
- cu.colu=0xFFFFFFFF;
- multimesh->data[i+color_from+0]=cu.colf;
+ cu.colu = 0xFFFFFFFF;
+ multimesh->data[i + color_from + 0] = cu.colf;
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
- multimesh->data[i+color_from+0]=1.0;
- multimesh->data[i+color_from+1]=1.0;
- multimesh->data[i+color_from+2]=1.0;
- multimesh->data[i+color_from+3]=1.0;
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) {
+ multimesh->data[i + color_from + 0] = 1.0;
+ multimesh->data[i + color_from + 1] = 1.0;
+ multimesh->data[i + color_from + 2] = 1.0;
+ multimesh->data[i + color_from + 3] = 1.0;
}
}
- glGenBuffers(1,&multimesh->buffer);
- glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer);
- glBufferData(GL_ARRAY_BUFFER,multimesh->data.size()*sizeof(float),NULL,GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER,0);
-
+ glGenBuffers(1, &multimesh->buffer);
+ glBindBuffer(GL_ARRAY_BUFFER, multimesh->buffer);
+ glBufferData(GL_ARRAY_BUFFER, multimesh->data.size() * sizeof(float), NULL, GL_DYNAMIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
}
- multimesh->dirty_data=true;
- multimesh->dirty_aabb=true;
+ multimesh->dirty_data = true;
+ multimesh->dirty_aabb = true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
-
}
-int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const{
+int RasterizerStorageGLES3::multimesh_get_instance_count(RID p_multimesh) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,0);
+ ERR_FAIL_COND_V(!multimesh, 0);
return multimesh->size;
}
-void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
+void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
@@ -3666,8 +3471,7 @@ void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
}
}
- multimesh->mesh=p_mesh;
-
+ multimesh->mesh = p_mesh;
if (multimesh->mesh.is_valid()) {
Mesh *mesh = mesh_owner.getornull(multimesh->mesh);
@@ -3676,173 +3480,171 @@ void RasterizerStorageGLES3::multimesh_set_mesh(RID p_multimesh,RID p_mesh){
}
}
- multimesh->dirty_aabb=true;
+ multimesh->dirty_aabb = true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
-void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform){
+void RasterizerStorageGLES3::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
- ERR_FAIL_INDEX(p_index,multimesh->size);
- ERR_FAIL_COND(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D);
+ ERR_FAIL_INDEX(p_index, multimesh->size);
+ ERR_FAIL_COND(multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D);
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index];
- dataptr[ 0]=p_transform.basis.elements[0][0];
- dataptr[ 1]=p_transform.basis.elements[0][1];
- dataptr[ 2]=p_transform.basis.elements[0][2];
- dataptr[ 3]=p_transform.origin.x;
- dataptr[ 4]=p_transform.basis.elements[1][0];
- dataptr[ 5]=p_transform.basis.elements[1][1];
- dataptr[ 6]=p_transform.basis.elements[1][2];
- dataptr[ 7]=p_transform.origin.y;
- dataptr[ 8]=p_transform.basis.elements[2][0];
- dataptr[ 9]=p_transform.basis.elements[2][1];
- dataptr[10]=p_transform.basis.elements[2][2];
- dataptr[11]=p_transform.origin.z;
+ dataptr[0] = p_transform.basis.elements[0][0];
+ dataptr[1] = p_transform.basis.elements[0][1];
+ dataptr[2] = p_transform.basis.elements[0][2];
+ dataptr[3] = p_transform.origin.x;
+ dataptr[4] = p_transform.basis.elements[1][0];
+ dataptr[5] = p_transform.basis.elements[1][1];
+ dataptr[6] = p_transform.basis.elements[1][2];
+ dataptr[7] = p_transform.origin.y;
+ dataptr[8] = p_transform.basis.elements[2][0];
+ dataptr[9] = p_transform.basis.elements[2][1];
+ dataptr[10] = p_transform.basis.elements[2][2];
+ dataptr[11] = p_transform.origin.z;
- multimesh->dirty_data=true;
- multimesh->dirty_aabb=true;
+ multimesh->dirty_data = true;
+ multimesh->dirty_aabb = true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
-void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform){
+void RasterizerStorageGLES3::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
- ERR_FAIL_INDEX(p_index,multimesh->size);
- ERR_FAIL_COND(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D);
+ ERR_FAIL_INDEX(p_index, multimesh->size);
+ ERR_FAIL_COND(multimesh->transform_format == VS::MULTIMESH_TRANSFORM_3D);
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index];
- dataptr[ 0]=p_transform.elements[0][0];
- dataptr[ 1]=p_transform.elements[1][0];
- dataptr[ 2]=0;
- dataptr[ 3]=p_transform.elements[2][0];
- dataptr[ 4]=p_transform.elements[0][1];
- dataptr[ 5]=p_transform.elements[1][1];
- dataptr[ 6]=0;
- dataptr[ 7]=p_transform.elements[2][1];
+ dataptr[0] = p_transform.elements[0][0];
+ dataptr[1] = p_transform.elements[1][0];
+ dataptr[2] = 0;
+ dataptr[3] = p_transform.elements[2][0];
+ dataptr[4] = p_transform.elements[0][1];
+ dataptr[5] = p_transform.elements[1][1];
+ dataptr[6] = 0;
+ dataptr[7] = p_transform.elements[2][1];
- multimesh->dirty_data=true;
- multimesh->dirty_aabb=true;
+ multimesh->dirty_data = true;
+ multimesh->dirty_aabb = true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
-void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color){
+void RasterizerStorageGLES3::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
- ERR_FAIL_INDEX(p_index,multimesh->size);
- ERR_FAIL_COND(multimesh->color_format==VS::MULTIMESH_COLOR_NONE);
+ ERR_FAIL_INDEX(p_index, multimesh->size);
+ ERR_FAIL_COND(multimesh->color_format == VS::MULTIMESH_COLOR_NONE);
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index+multimesh->xform_floats];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index + multimesh->xform_floats];
- if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+ if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) {
- uint8_t *data8=(uint8_t*)dataptr;
- data8[0]=CLAMP(p_color.r*255.0,0,255);
- data8[1]=CLAMP(p_color.g*255.0,0,255);
- data8[2]=CLAMP(p_color.b*255.0,0,255);
- data8[3]=CLAMP(p_color.a*255.0,0,255);
+ uint8_t *data8 = (uint8_t *)dataptr;
+ data8[0] = CLAMP(p_color.r * 255.0, 0, 255);
+ data8[1] = CLAMP(p_color.g * 255.0, 0, 255);
+ data8[2] = CLAMP(p_color.b * 255.0, 0, 255);
+ data8[3] = CLAMP(p_color.a * 255.0, 0, 255);
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
- dataptr[ 0]=p_color.r;
- dataptr[ 1]=p_color.g;
- dataptr[ 2]=p_color.b;
- dataptr[ 3]=p_color.a;
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) {
+ dataptr[0] = p_color.r;
+ dataptr[1] = p_color.g;
+ dataptr[2] = p_color.b;
+ dataptr[3] = p_color.a;
}
-
- multimesh->dirty_data=true;
- multimesh->dirty_aabb=true;
+ multimesh->dirty_data = true;
+ multimesh->dirty_aabb = true;
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
}
-RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const{
+RID RasterizerStorageGLES3::multimesh_get_mesh(RID p_multimesh) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,RID());
+ ERR_FAIL_COND_V(!multimesh, RID());
return multimesh->mesh;
}
-
-Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh,int p_index) const{
+Transform RasterizerStorageGLES3::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,Transform());
- ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform());
- ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D,Transform());
+ ERR_FAIL_COND_V(!multimesh, Transform());
+ ERR_FAIL_INDEX_V(p_index, multimesh->size, Transform());
+ ERR_FAIL_COND_V(multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D, Transform());
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index];
Transform xform;
- xform.basis.elements[0][0]=dataptr[ 0];
- xform.basis.elements[0][1]=dataptr[ 1];
- xform.basis.elements[0][2]=dataptr[ 2];
- xform.origin.x=dataptr[ 3];
- xform.basis.elements[1][0]=dataptr[ 4];
- xform.basis.elements[1][1]=dataptr[ 5];
- xform.basis.elements[1][2]=dataptr[ 6];
- xform.origin.y=dataptr[ 7];
- xform.basis.elements[2][0]=dataptr[ 8];
- xform.basis.elements[2][1]=dataptr[ 9];
- xform.basis.elements[2][2]=dataptr[10];
- xform.origin.z=dataptr[11];
+ xform.basis.elements[0][0] = dataptr[0];
+ xform.basis.elements[0][1] = dataptr[1];
+ xform.basis.elements[0][2] = dataptr[2];
+ xform.origin.x = dataptr[3];
+ xform.basis.elements[1][0] = dataptr[4];
+ xform.basis.elements[1][1] = dataptr[5];
+ xform.basis.elements[1][2] = dataptr[6];
+ xform.origin.y = dataptr[7];
+ xform.basis.elements[2][0] = dataptr[8];
+ xform.basis.elements[2][1] = dataptr[9];
+ xform.basis.elements[2][2] = dataptr[10];
+ xform.origin.z = dataptr[11];
return xform;
}
-Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const{
+Transform2D RasterizerStorageGLES3::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,Transform2D());
- ERR_FAIL_INDEX_V(p_index,multimesh->size,Transform2D());
- ERR_FAIL_COND_V(multimesh->transform_format==VS::MULTIMESH_TRANSFORM_3D,Transform2D());
+ ERR_FAIL_COND_V(!multimesh, Transform2D());
+ ERR_FAIL_INDEX_V(p_index, multimesh->size, Transform2D());
+ ERR_FAIL_COND_V(multimesh->transform_format == VS::MULTIMESH_TRANSFORM_3D, Transform2D());
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index];
Transform2D xform;
- xform.elements[0][0]=dataptr[ 0];
- xform.elements[1][0]=dataptr[ 1];
- xform.elements[2][0]=dataptr[ 3];
- xform.elements[0][1]=dataptr[ 4];
- xform.elements[1][1]=dataptr[ 5];
- xform.elements[2][1]=dataptr[ 7];
+ xform.elements[0][0] = dataptr[0];
+ xform.elements[1][0] = dataptr[1];
+ xform.elements[2][0] = dataptr[3];
+ xform.elements[0][1] = dataptr[4];
+ xform.elements[1][1] = dataptr[5];
+ xform.elements[2][1] = dataptr[7];
return xform;
}
-Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p_index) const{
+Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,Color());
- ERR_FAIL_INDEX_V(p_index,multimesh->size,Color());
- ERR_FAIL_COND_V(multimesh->color_format==VS::MULTIMESH_COLOR_NONE,Color());
+ ERR_FAIL_COND_V(!multimesh, Color());
+ ERR_FAIL_INDEX_V(p_index, multimesh->size, Color());
+ ERR_FAIL_COND_V(multimesh->color_format == VS::MULTIMESH_COLOR_NONE, Color());
- int stride = multimesh->color_floats+multimesh->xform_floats;
- float *dataptr=&multimesh->data[stride*p_index+multimesh->color_floats];
+ int stride = multimesh->color_floats + multimesh->xform_floats;
+ float *dataptr = &multimesh->data[stride * p_index + multimesh->color_floats];
- if (multimesh->color_format==VS::MULTIMESH_COLOR_8BIT) {
+ if (multimesh->color_format == VS::MULTIMESH_COLOR_8BIT) {
union {
uint32_t colu;
float colf;
@@ -3850,130 +3652,124 @@ Color RasterizerStorageGLES3::multimesh_instance_get_color(RID p_multimesh,int p
return Color::hex(BSWAP32(cu.colu));
- } else if (multimesh->color_format==VS::MULTIMESH_COLOR_FLOAT) {
+ } else if (multimesh->color_format == VS::MULTIMESH_COLOR_FLOAT) {
Color c;
- c.r=dataptr[ 0];
- c.g=dataptr[ 1];
- c.b=dataptr[ 2];
- c.a=dataptr[ 3];
+ c.r = dataptr[0];
+ c.g = dataptr[1];
+ c.b = dataptr[2];
+ c.a = dataptr[3];
return c;
}
return Color();
-
}
-void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh,int p_visible){
+void RasterizerStorageGLES3::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
ERR_FAIL_COND(!multimesh);
- multimesh->visible_instances=p_visible;
+ multimesh->visible_instances = p_visible;
}
-int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const{
+int RasterizerStorageGLES3::multimesh_get_visible_instances(RID p_multimesh) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,-1);
+ ERR_FAIL_COND_V(!multimesh, -1);
return multimesh->visible_instances;
}
-Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const{
+Rect3 RasterizerStorageGLES3::multimesh_get_aabb(RID p_multimesh) const {
MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
- ERR_FAIL_COND_V(!multimesh,Rect3());
+ ERR_FAIL_COND_V(!multimesh, Rect3());
- const_cast<RasterizerStorageGLES3*>(this)->update_dirty_multimeshes(); //update pending AABBs
+ const_cast<RasterizerStorageGLES3 *>(this)->update_dirty_multimeshes(); //update pending AABBs
return multimesh->aabb;
}
void RasterizerStorageGLES3::update_dirty_multimeshes() {
- while(multimesh_update_list.first()) {
+ while (multimesh_update_list.first()) {
MultiMesh *multimesh = multimesh_update_list.first()->self();
if (multimesh->size && multimesh->dirty_data) {
-
- glBindBuffer(GL_ARRAY_BUFFER,multimesh->buffer);
- glBufferSubData(GL_ARRAY_BUFFER,0,multimesh->data.size()*sizeof(float),multimesh->data.ptr());
- glBindBuffer(GL_ARRAY_BUFFER,0);
-
-
+ glBindBuffer(GL_ARRAY_BUFFER, multimesh->buffer);
+ glBufferSubData(GL_ARRAY_BUFFER, 0, multimesh->data.size() * sizeof(float), multimesh->data.ptr());
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
}
-
-
if (multimesh->size && multimesh->dirty_aabb) {
Rect3 mesh_aabb;
if (multimesh->mesh.is_valid()) {
- mesh_aabb=mesh_get_aabb(multimesh->mesh,RID());
+ mesh_aabb = mesh_get_aabb(multimesh->mesh, RID());
} else {
- mesh_aabb.size+=Vector3(0.001,0.001,0.001);
+ mesh_aabb.size += Vector3(0.001, 0.001, 0.001);
}
- int stride=multimesh->color_floats+multimesh->xform_floats;
+ int stride = multimesh->color_floats + multimesh->xform_floats;
int count = multimesh->data.size();
- float *data=multimesh->data.ptr();
+ float *data = multimesh->data.ptr();
Rect3 aabb;
- if (multimesh->transform_format==VS::MULTIMESH_TRANSFORM_2D) {
+ if (multimesh->transform_format == VS::MULTIMESH_TRANSFORM_2D) {
- for(int i=0;i<count;i+=stride) {
+ for (int i = 0; i < count; i += stride) {
- float *dataptr=&data[i];
+ float *dataptr = &data[i];
Transform xform;
- xform.basis[0][0]=dataptr[ 0];
- xform.basis[0][1]=dataptr[ 1];
- xform.origin[0]=dataptr[ 3];
- xform.basis[1][0]=dataptr[ 4];
- xform.basis[1][1]=dataptr[ 5];
- xform.origin[1]=dataptr[ 7];
+ xform.basis[0][0] = dataptr[0];
+ xform.basis[0][1] = dataptr[1];
+ xform.origin[0] = dataptr[3];
+ xform.basis[1][0] = dataptr[4];
+ xform.basis[1][1] = dataptr[5];
+ xform.origin[1] = dataptr[7];
Rect3 laabb = xform.xform(mesh_aabb);
- if (i==0)
- aabb=laabb;
+ if (i == 0)
+ aabb = laabb;
else
aabb.merge_with(laabb);
}
} else {
- for(int i=0;i<count;i+=stride) {
+ for (int i = 0; i < count; i += stride) {
- float *dataptr=&data[i];
+ float *dataptr = &data[i];
Transform xform;
- xform.basis.elements[0][0]=dataptr[ 0];
- xform.basis.elements[0][1]=dataptr[ 1];
- xform.basis.elements[0][2]=dataptr[ 2];
- xform.origin.x=dataptr[ 3];
- xform.basis.elements[1][0]=dataptr[ 4];
- xform.basis.elements[1][1]=dataptr[ 5];
- xform.basis.elements[1][2]=dataptr[ 6];
- xform.origin.y=dataptr[ 7];
- xform.basis.elements[2][0]=dataptr[ 8];
- xform.basis.elements[2][1]=dataptr[ 9];
- xform.basis.elements[2][2]=dataptr[10];
- xform.origin.z=dataptr[11];
+ xform.basis.elements[0][0] = dataptr[0];
+ xform.basis.elements[0][1] = dataptr[1];
+ xform.basis.elements[0][2] = dataptr[2];
+ xform.origin.x = dataptr[3];
+ xform.basis.elements[1][0] = dataptr[4];
+ xform.basis.elements[1][1] = dataptr[5];
+ xform.basis.elements[1][2] = dataptr[6];
+ xform.origin.y = dataptr[7];
+ xform.basis.elements[2][0] = dataptr[8];
+ xform.basis.elements[2][1] = dataptr[9];
+ xform.basis.elements[2][2] = dataptr[10];
+ xform.origin.z = dataptr[11];
Rect3 laabb = xform.xform(mesh_aabb);
- if (i==0)
- aabb=laabb;
+ if (i == 0)
+ aabb = laabb;
else
aabb.merge_with(laabb);
}
}
- multimesh->aabb=aabb;
+ multimesh->aabb = aabb;
}
- multimesh->dirty_aabb=false;
- multimesh->dirty_data=false;
+ multimesh->dirty_aabb = false;
+ multimesh->dirty_data = false;
multimesh->instance_change_notify();
@@ -3983,30 +3779,26 @@ void RasterizerStorageGLES3::update_dirty_multimeshes() {
/* IMMEDIATE API */
-
RID RasterizerStorageGLES3::immediate_create() {
- Immediate *im = memnew( Immediate );
+ Immediate *im = memnew(Immediate);
return immediate_owner.make_rid(im);
-
}
-void RasterizerStorageGLES3::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture){
+void RasterizerStorageGLES3::immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(im->building);
Immediate::Chunk ic;
- ic.texture=p_texture;
- ic.primitive=p_rimitive;
+ ic.texture = p_texture;
+ ic.primitive = p_rimitive;
im->chunks.push_back(ic);
- im->mask=0;
- im->building=true;
-
-
+ im->mask = 0;
+ im->building = true;
}
-void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_vertex){
+void RasterizerStorageGLES3::immediate_vertex(RID p_immediate, const Vector3 &p_vertex) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
@@ -4014,92 +3806,83 @@ void RasterizerStorageGLES3::immediate_vertex(RID p_immediate,const Vector3& p_v
Immediate::Chunk *c = &im->chunks.back()->get();
+ if (c->vertices.empty() && im->chunks.size() == 1) {
- if (c->vertices.empty() && im->chunks.size()==1) {
-
- im->aabb.pos=p_vertex;
- im->aabb.size=Vector3();
+ im->aabb.pos = p_vertex;
+ im->aabb.size = Vector3();
} else {
im->aabb.expand_to(p_vertex);
}
- if (im->mask&VS::ARRAY_FORMAT_NORMAL)
+ if (im->mask & VS::ARRAY_FORMAT_NORMAL)
c->normals.push_back(chunk_normal);
- if (im->mask&VS::ARRAY_FORMAT_TANGENT)
+ if (im->mask & VS::ARRAY_FORMAT_TANGENT)
c->tangents.push_back(chunk_tangent);
- if (im->mask&VS::ARRAY_FORMAT_COLOR)
+ if (im->mask & VS::ARRAY_FORMAT_COLOR)
c->colors.push_back(chunk_color);
- if (im->mask&VS::ARRAY_FORMAT_TEX_UV)
+ if (im->mask & VS::ARRAY_FORMAT_TEX_UV)
c->uvs.push_back(chunk_uv);
- if (im->mask&VS::ARRAY_FORMAT_TEX_UV2)
+ if (im->mask & VS::ARRAY_FORMAT_TEX_UV2)
c->uvs2.push_back(chunk_uv2);
- im->mask|=VS::ARRAY_FORMAT_VERTEX;
+ im->mask |= VS::ARRAY_FORMAT_VERTEX;
c->vertices.push_back(p_vertex);
-
}
-
-void RasterizerStorageGLES3::immediate_normal(RID p_immediate,const Vector3& p_normal){
+void RasterizerStorageGLES3::immediate_normal(RID p_immediate, const Vector3 &p_normal) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->mask|=VS::ARRAY_FORMAT_NORMAL;
- chunk_normal=p_normal;
-
+ im->mask |= VS::ARRAY_FORMAT_NORMAL;
+ chunk_normal = p_normal;
}
-void RasterizerStorageGLES3::immediate_tangent(RID p_immediate,const Plane& p_tangent){
+void RasterizerStorageGLES3::immediate_tangent(RID p_immediate, const Plane &p_tangent) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->mask|=VS::ARRAY_FORMAT_TANGENT;
- chunk_tangent=p_tangent;
-
+ im->mask |= VS::ARRAY_FORMAT_TANGENT;
+ chunk_tangent = p_tangent;
}
-void RasterizerStorageGLES3::immediate_color(RID p_immediate,const Color& p_color){
+void RasterizerStorageGLES3::immediate_color(RID p_immediate, const Color &p_color) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->mask|=VS::ARRAY_FORMAT_COLOR;
- chunk_color=p_color;
-
+ im->mask |= VS::ARRAY_FORMAT_COLOR;
+ chunk_color = p_color;
}
-void RasterizerStorageGLES3::immediate_uv(RID p_immediate,const Vector2& tex_uv){
+void RasterizerStorageGLES3::immediate_uv(RID p_immediate, const Vector2 &tex_uv) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->mask|=VS::ARRAY_FORMAT_TEX_UV;
- chunk_uv=tex_uv;
-
+ im->mask |= VS::ARRAY_FORMAT_TEX_UV;
+ chunk_uv = tex_uv;
}
-void RasterizerStorageGLES3::immediate_uv2(RID p_immediate,const Vector2& tex_uv){
+void RasterizerStorageGLES3::immediate_uv2(RID p_immediate, const Vector2 &tex_uv) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->mask|=VS::ARRAY_FORMAT_TEX_UV2;
- chunk_uv2=tex_uv;
-
+ im->mask |= VS::ARRAY_FORMAT_TEX_UV2;
+ chunk_uv2 = tex_uv;
}
-void RasterizerStorageGLES3::immediate_end(RID p_immediate){
+void RasterizerStorageGLES3::immediate_end(RID p_immediate) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
ERR_FAIL_COND(!im->building);
- im->building=false;
+ im->building = false;
im->instance_change_notify();
-
}
void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
@@ -4109,279 +3892,264 @@ void RasterizerStorageGLES3::immediate_clear(RID p_immediate) {
im->chunks.clear();
im->instance_change_notify();
-
}
Rect3 RasterizerStorageGLES3::immediate_get_aabb(RID p_immediate) const {
Immediate *im = immediate_owner.get(p_immediate);
- ERR_FAIL_COND_V(!im,Rect3());
+ ERR_FAIL_COND_V(!im, Rect3());
return im->aabb;
}
-void RasterizerStorageGLES3::immediate_set_material(RID p_immediate,RID p_material) {
+void RasterizerStorageGLES3::immediate_set_material(RID p_immediate, RID p_material) {
Immediate *im = immediate_owner.get(p_immediate);
ERR_FAIL_COND(!im);
- im->material=p_material;
+ im->material = p_material;
im->instance_material_change_notify();
-
}
RID RasterizerStorageGLES3::immediate_get_material(RID p_immediate) const {
const Immediate *im = immediate_owner.get(p_immediate);
- ERR_FAIL_COND_V(!im,RID());
+ ERR_FAIL_COND_V(!im, RID());
return im->material;
-
}
/* SKELETON API */
-RID RasterizerStorageGLES3::skeleton_create(){
+RID RasterizerStorageGLES3::skeleton_create() {
- Skeleton *skeleton = memnew( Skeleton );
+ Skeleton *skeleton = memnew(Skeleton);
return skeleton_owner.make_rid(skeleton);
}
-void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton){
+void RasterizerStorageGLES3::skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton) {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
- ERR_FAIL_COND(p_bones<0);
+ ERR_FAIL_COND(p_bones < 0);
- if (skeleton->size==p_bones && skeleton->use_2d==p_2d_skeleton)
+ if (skeleton->size == p_bones && skeleton->use_2d == p_2d_skeleton)
return;
if (skeleton->ubo) {
- glDeleteBuffers(1,&skeleton->ubo);
- skeleton->ubo=0;
+ glDeleteBuffers(1, &skeleton->ubo);
+ skeleton->ubo = 0;
}
- skeleton->size=p_bones;
+ skeleton->size = p_bones;
if (p_2d_skeleton) {
- skeleton->bones.resize(p_bones*8);
- for(int i=0;i<skeleton->bones.size();i+=8) {
- skeleton->bones[i+0]=1;
- skeleton->bones[i+1]=0;
- skeleton->bones[i+2]=0;
- skeleton->bones[i+3]=0;
- skeleton->bones[i+4]=0;
- skeleton->bones[i+5]=1;
- skeleton->bones[i+6]=0;
- skeleton->bones[i+7]=0;
+ skeleton->bones.resize(p_bones * 8);
+ for (int i = 0; i < skeleton->bones.size(); i += 8) {
+ skeleton->bones[i + 0] = 1;
+ skeleton->bones[i + 1] = 0;
+ skeleton->bones[i + 2] = 0;
+ skeleton->bones[i + 3] = 0;
+ skeleton->bones[i + 4] = 0;
+ skeleton->bones[i + 5] = 1;
+ skeleton->bones[i + 6] = 0;
+ skeleton->bones[i + 7] = 0;
}
} else {
- skeleton->bones.resize(p_bones*12);
- for(int i=0;i<skeleton->bones.size();i+=12) {
- skeleton->bones[i+0]=1;
- skeleton->bones[i+1]=0;
- skeleton->bones[i+2]=0;
- skeleton->bones[i+3]=0;
- skeleton->bones[i+4]=0;
- skeleton->bones[i+5]=1;
- skeleton->bones[i+6]=0;
- skeleton->bones[i+7]=0;
- skeleton->bones[i+8]=0;
- skeleton->bones[i+9]=0;
- skeleton->bones[i+10]=1;
- skeleton->bones[i+11]=0;
+ skeleton->bones.resize(p_bones * 12);
+ for (int i = 0; i < skeleton->bones.size(); i += 12) {
+ skeleton->bones[i + 0] = 1;
+ skeleton->bones[i + 1] = 0;
+ skeleton->bones[i + 2] = 0;
+ skeleton->bones[i + 3] = 0;
+ skeleton->bones[i + 4] = 0;
+ skeleton->bones[i + 5] = 1;
+ skeleton->bones[i + 6] = 0;
+ skeleton->bones[i + 7] = 0;
+ skeleton->bones[i + 8] = 0;
+ skeleton->bones[i + 9] = 0;
+ skeleton->bones[i + 10] = 1;
+ skeleton->bones[i + 11] = 0;
}
-
}
-
-
if (p_bones) {
glGenBuffers(1, &skeleton->ubo);
glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo);
- glBufferData(GL_UNIFORM_BUFFER, skeleton->bones.size()*sizeof(float), NULL, GL_DYNAMIC_DRAW);
+ glBufferData(GL_UNIFORM_BUFFER, skeleton->bones.size() * sizeof(float), NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
if (!skeleton->update_list.in_list()) {
skeleton_update_list.add(&skeleton->update_list);
}
-
-
-
}
-int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const{
+int RasterizerStorageGLES3::skeleton_get_bone_count(RID p_skeleton) const {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
- ERR_FAIL_COND_V(!skeleton,0);
+ ERR_FAIL_COND_V(!skeleton, 0);
return skeleton->size;
}
-void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform){
+void RasterizerStorageGLES3::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
- ERR_FAIL_INDEX(p_bone,skeleton->size);
+ ERR_FAIL_INDEX(p_bone, skeleton->size);
ERR_FAIL_COND(skeleton->use_2d);
- float * bones = skeleton->bones.ptr();
- bones[p_bone*12+ 0]=p_transform.basis.elements[0][0];
- bones[p_bone*12+ 1]=p_transform.basis.elements[0][1];
- bones[p_bone*12+ 2]=p_transform.basis.elements[0][2];
- bones[p_bone*12+ 3]=p_transform.origin.x;
- bones[p_bone*12+ 4]=p_transform.basis.elements[1][0];
- bones[p_bone*12+ 5]=p_transform.basis.elements[1][1];
- bones[p_bone*12+ 6]=p_transform.basis.elements[1][2];
- bones[p_bone*12+ 7]=p_transform.origin.y;
- bones[p_bone*12+ 8]=p_transform.basis.elements[2][0];
- bones[p_bone*12+ 9]=p_transform.basis.elements[2][1];
- bones[p_bone*12+10]=p_transform.basis.elements[2][2];
- bones[p_bone*12+11]=p_transform.origin.z;
+ float *bones = skeleton->bones.ptr();
+ bones[p_bone * 12 + 0] = p_transform.basis.elements[0][0];
+ bones[p_bone * 12 + 1] = p_transform.basis.elements[0][1];
+ bones[p_bone * 12 + 2] = p_transform.basis.elements[0][2];
+ bones[p_bone * 12 + 3] = p_transform.origin.x;
+ bones[p_bone * 12 + 4] = p_transform.basis.elements[1][0];
+ bones[p_bone * 12 + 5] = p_transform.basis.elements[1][1];
+ bones[p_bone * 12 + 6] = p_transform.basis.elements[1][2];
+ bones[p_bone * 12 + 7] = p_transform.origin.y;
+ bones[p_bone * 12 + 8] = p_transform.basis.elements[2][0];
+ bones[p_bone * 12 + 9] = p_transform.basis.elements[2][1];
+ bones[p_bone * 12 + 10] = p_transform.basis.elements[2][2];
+ bones[p_bone * 12 + 11] = p_transform.origin.z;
if (!skeleton->update_list.in_list()) {
skeleton_update_list.add(&skeleton->update_list);
}
-
}
-
-Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton,int p_bone) const{
+Transform RasterizerStorageGLES3::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
- ERR_FAIL_COND_V(!skeleton,Transform());
- ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform());
- ERR_FAIL_COND_V(skeleton->use_2d,Transform());
+ ERR_FAIL_COND_V(!skeleton, Transform());
+ ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform());
+ ERR_FAIL_COND_V(skeleton->use_2d, Transform());
- float * bones = skeleton->bones.ptr();
+ float *bones = skeleton->bones.ptr();
Transform mtx;
- mtx.basis.elements[0][0]=bones[p_bone*12+ 0];
- mtx.basis.elements[0][1]=bones[p_bone*12+ 1];
- mtx.basis.elements[0][2]=bones[p_bone*12+ 2];
- mtx.origin.x=bones[p_bone*12+ 3];
- mtx.basis.elements[1][0]=bones[p_bone*12+ 4];
- mtx.basis.elements[1][1]=bones[p_bone*12+ 5];
- mtx.basis.elements[1][2]=bones[p_bone*12+ 6];
- mtx.origin.y=bones[p_bone*12+ 7];
- mtx.basis.elements[2][0]=bones[p_bone*12+ 8];
- mtx.basis.elements[2][1]=bones[p_bone*12+ 9];
- mtx.basis.elements[2][2]=bones[p_bone*12+10];
- mtx.origin.z=bones[p_bone*12+11];
+ mtx.basis.elements[0][0] = bones[p_bone * 12 + 0];
+ mtx.basis.elements[0][1] = bones[p_bone * 12 + 1];
+ mtx.basis.elements[0][2] = bones[p_bone * 12 + 2];
+ mtx.origin.x = bones[p_bone * 12 + 3];
+ mtx.basis.elements[1][0] = bones[p_bone * 12 + 4];
+ mtx.basis.elements[1][1] = bones[p_bone * 12 + 5];
+ mtx.basis.elements[1][2] = bones[p_bone * 12 + 6];
+ mtx.origin.y = bones[p_bone * 12 + 7];
+ mtx.basis.elements[2][0] = bones[p_bone * 12 + 8];
+ mtx.basis.elements[2][1] = bones[p_bone * 12 + 9];
+ mtx.basis.elements[2][2] = bones[p_bone * 12 + 10];
+ mtx.origin.z = bones[p_bone * 12 + 11];
return mtx;
}
-void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform){
+void RasterizerStorageGLES3::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
- ERR_FAIL_INDEX(p_bone,skeleton->size);
+ ERR_FAIL_INDEX(p_bone, skeleton->size);
ERR_FAIL_COND(!skeleton->use_2d);
- float * bones = skeleton->bones.ptr();
- bones[p_bone*12+ 0]=p_transform.elements[0][0];
- bones[p_bone*12+ 1]=p_transform.elements[1][0];
- bones[p_bone*12+ 2]=0;
- bones[p_bone*12+ 3]=p_transform.elements[2][0];
- bones[p_bone*12+ 4]=p_transform.elements[0][1];
- bones[p_bone*12+ 5]=p_transform.elements[1][1];
- bones[p_bone*12+ 6]=0;
- bones[p_bone*12+ 7]=p_transform.elements[2][1];
+ float *bones = skeleton->bones.ptr();
+ bones[p_bone * 12 + 0] = p_transform.elements[0][0];
+ bones[p_bone * 12 + 1] = p_transform.elements[1][0];
+ bones[p_bone * 12 + 2] = 0;
+ bones[p_bone * 12 + 3] = p_transform.elements[2][0];
+ bones[p_bone * 12 + 4] = p_transform.elements[0][1];
+ bones[p_bone * 12 + 5] = p_transform.elements[1][1];
+ bones[p_bone * 12 + 6] = 0;
+ bones[p_bone * 12 + 7] = p_transform.elements[2][1];
if (!skeleton->update_list.in_list()) {
skeleton_update_list.add(&skeleton->update_list);
}
-
}
-Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const{
+Transform2D RasterizerStorageGLES3::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
-
- ERR_FAIL_COND_V(!skeleton,Transform2D());
- ERR_FAIL_INDEX_V(p_bone,skeleton->size,Transform2D());
- ERR_FAIL_COND_V(!skeleton->use_2d,Transform2D());
+ ERR_FAIL_COND_V(!skeleton, Transform2D());
+ ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform2D());
+ ERR_FAIL_COND_V(!skeleton->use_2d, Transform2D());
Transform2D mtx;
- float * bones = skeleton->bones.ptr();
- mtx.elements[0][0]=bones[p_bone*12+ 0];
- mtx.elements[1][0]=bones[p_bone*12+ 1];
- mtx.elements[2][0]=bones[p_bone*12+ 3];
- mtx.elements[0][1]=bones[p_bone*12+ 4];
- mtx.elements[1][1]=bones[p_bone*12+ 5];
- mtx.elements[2][1]=bones[p_bone*12+ 7];
+ float *bones = skeleton->bones.ptr();
+ mtx.elements[0][0] = bones[p_bone * 12 + 0];
+ mtx.elements[1][0] = bones[p_bone * 12 + 1];
+ mtx.elements[2][0] = bones[p_bone * 12 + 3];
+ mtx.elements[0][1] = bones[p_bone * 12 + 4];
+ mtx.elements[1][1] = bones[p_bone * 12 + 5];
+ mtx.elements[2][1] = bones[p_bone * 12 + 7];
return mtx;
}
void RasterizerStorageGLES3::update_dirty_skeletons() {
- while(skeleton_update_list.first()) {
+ while (skeleton_update_list.first()) {
Skeleton *skeleton = skeleton_update_list.first()->self();
if (skeleton->size) {
glBindBuffer(GL_UNIFORM_BUFFER, skeleton->ubo);
- glBufferSubData(GL_UNIFORM_BUFFER,0,skeleton->bones.size()*sizeof(float),skeleton->bones.ptr());
+ glBufferSubData(GL_UNIFORM_BUFFER, 0, skeleton->bones.size() * sizeof(float), skeleton->bones.ptr());
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
- for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
+ for (Set<RasterizerScene::InstanceBase *>::Element *E = skeleton->instances.front(); E; E = E->next()) {
E->get()->base_changed();
}
skeleton_update_list.remove(skeleton_update_list.first());
}
-
}
/* Light API */
-RID RasterizerStorageGLES3::light_create(VS::LightType p_type){
-
- Light *light = memnew( Light );
- light->type=p_type;
+RID RasterizerStorageGLES3::light_create(VS::LightType p_type) {
- light->param[VS::LIGHT_PARAM_ENERGY]=1.0;
- light->param[VS::LIGHT_PARAM_SPECULAR]=0.5;
- light->param[VS::LIGHT_PARAM_RANGE]=1.0;
- light->param[VS::LIGHT_PARAM_SPOT_ANGLE]=45;
- light->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE]=45;
- light->param[VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE]=0;
- light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET]=0.1;
- light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET]=0.3;
- light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET]=0.6;
- light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS]=0.1;
- light->param[VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE]=0.1;
+ Light *light = memnew(Light);
+ light->type = p_type;
+ light->param[VS::LIGHT_PARAM_ENERGY] = 1.0;
+ light->param[VS::LIGHT_PARAM_SPECULAR] = 0.5;
+ light->param[VS::LIGHT_PARAM_RANGE] = 1.0;
+ light->param[VS::LIGHT_PARAM_SPOT_ANGLE] = 45;
+ light->param[VS::LIGHT_PARAM_CONTACT_SHADOW_SIZE] = 45;
+ light->param[VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE] = 0;
+ light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET] = 0.1;
+ light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET] = 0.3;
+ light->param[VS::LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET] = 0.6;
+ light->param[VS::LIGHT_PARAM_SHADOW_NORMAL_BIAS] = 0.1;
+ light->param[VS::LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE] = 0.1;
- light->color=Color(1,1,1,1);
- light->shadow=false;
- light->negative=false;
- light->cull_mask=0xFFFFFFFF;
- light->directional_shadow_mode=VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
- light->omni_shadow_mode=VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID;
- light->omni_shadow_detail=VS::LIGHT_OMNI_SHADOW_DETAIL_VERTICAL;
- light->directional_blend_splits=false;
+ light->color = Color(1, 1, 1, 1);
+ light->shadow = false;
+ light->negative = false;
+ light->cull_mask = 0xFFFFFFFF;
+ light->directional_shadow_mode = VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
+ light->omni_shadow_mode = VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID;
+ light->omni_shadow_detail = VS::LIGHT_OMNI_SHADOW_DETAIL_VERTICAL;
+ light->directional_blend_splits = false;
- light->version=0;
+ light->version = 0;
return light_owner.make_rid(light);
}
-void RasterizerStorageGLES3::light_set_color(RID p_light,const Color& p_color){
+void RasterizerStorageGLES3::light_set_color(RID p_light, const Color &p_color) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->color=p_color;
+ light->color = p_color;
}
-void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,float p_value){
+void RasterizerStorageGLES3::light_set_param(RID p_light, VS::LightParam p_param, float p_value) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- ERR_FAIL_INDEX(p_param,VS::LIGHT_PARAM_MAX);
+ ERR_FAIL_INDEX(p_param, VS::LIGHT_PARAM_MAX);
- switch(p_param) {
+ switch (p_param) {
case VS::LIGHT_PARAM_RANGE:
case VS::LIGHT_PARAM_SPOT_ANGLE:
case VS::LIGHT_PARAM_SHADOW_MAX_DISTANCE:
@@ -4397,185 +4165,173 @@ void RasterizerStorageGLES3::light_set_param(RID p_light,VS::LightParam p_param,
} break;
}
- light->param[p_param]=p_value;
+ light->param[p_param] = p_value;
}
-void RasterizerStorageGLES3::light_set_shadow(RID p_light,bool p_enabled){
+void RasterizerStorageGLES3::light_set_shadow(RID p_light, bool p_enabled) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->shadow=p_enabled;
+ light->shadow = p_enabled;
light->version++;
light->instance_change_notify();
}
-void RasterizerStorageGLES3::light_set_shadow_color(RID p_light,const Color& p_color) {
+void RasterizerStorageGLES3::light_set_shadow_color(RID p_light, const Color &p_color) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->shadow_color=p_color;
-
+ light->shadow_color = p_color;
}
-void RasterizerStorageGLES3::light_set_projector(RID p_light,RID p_texture){
+void RasterizerStorageGLES3::light_set_projector(RID p_light, RID p_texture) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->projector=p_texture;
+ light->projector = p_texture;
}
-void RasterizerStorageGLES3::light_set_negative(RID p_light,bool p_enable){
+void RasterizerStorageGLES3::light_set_negative(RID p_light, bool p_enable) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->negative=p_enable;
+ light->negative = p_enable;
}
-void RasterizerStorageGLES3::light_set_cull_mask(RID p_light,uint32_t p_mask){
+void RasterizerStorageGLES3::light_set_cull_mask(RID p_light, uint32_t p_mask) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->cull_mask=p_mask;
+ light->cull_mask = p_mask;
light->version++;
light->instance_change_notify();
-
}
-void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode) {
+void RasterizerStorageGLES3::light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->omni_shadow_mode=p_mode;
+ light->omni_shadow_mode = p_mode;
light->version++;
light->instance_change_notify();
-
-
}
VS::LightOmniShadowMode RasterizerStorageGLES3::light_omni_get_shadow_mode(RID p_light) {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,VS::LIGHT_OMNI_SHADOW_CUBE);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, VS::LIGHT_OMNI_SHADOW_CUBE);
return light->omni_shadow_mode;
}
+void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light, VS::LightOmniShadowDetail p_detail) {
-void RasterizerStorageGLES3::light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail) {
-
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->omni_shadow_detail=p_detail;
+ light->omni_shadow_detail = p_detail;
light->version++;
light->instance_change_notify();
}
+void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode) {
-void RasterizerStorageGLES3::light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode){
-
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->directional_shadow_mode=p_mode;
+ light->directional_shadow_mode = p_mode;
light->version++;
light->instance_change_notify();
-
}
-void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light,bool p_enable) {
+void RasterizerStorageGLES3::light_directional_set_blend_splits(RID p_light, bool p_enable) {
- Light * light = light_owner.getornull(p_light);
+ Light *light = light_owner.getornull(p_light);
ERR_FAIL_COND(!light);
- light->directional_blend_splits=p_enable;
+ light->directional_blend_splits = p_enable;
light->version++;
light->instance_change_notify();
-
}
-
bool RasterizerStorageGLES3::light_directional_get_blend_splits(RID p_light) const {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,false);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, false);
return light->directional_blend_splits;
}
VS::LightDirectionalShadowMode RasterizerStorageGLES3::light_directional_get_shadow_mode(RID p_light) {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
return light->directional_shadow_mode;
}
-
VS::LightType RasterizerStorageGLES3::light_get_type(RID p_light) const {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL);
return light->type;
}
-float RasterizerStorageGLES3::light_get_param(RID p_light,VS::LightParam p_param) {
+float RasterizerStorageGLES3::light_get_param(RID p_light, VS::LightParam p_param) {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL);
return light->param[p_param];
}
Color RasterizerStorageGLES3::light_get_color(RID p_light) {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,Color());
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, Color());
return light->color;
-
}
bool RasterizerStorageGLES3::light_has_shadow(RID p_light) const {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,VS::LIGHT_DIRECTIONAL);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, VS::LIGHT_DIRECTIONAL);
return light->shadow;
}
uint64_t RasterizerStorageGLES3::light_get_version(RID p_light) const {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,0);
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, 0);
return light->version;
}
-
Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
- const Light * light = light_owner.getornull(p_light);
- ERR_FAIL_COND_V(!light,Rect3());
+ const Light *light = light_owner.getornull(p_light);
+ ERR_FAIL_COND_V(!light, Rect3());
- switch( light->type ) {
+ switch (light->type) {
case VS::LIGHT_SPOT: {
- float len=light->param[VS::LIGHT_PARAM_RANGE];
- float size=Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE]))*len;
- return Rect3( Vector3( -size,-size,-len ), Vector3( size*2, size*2, len ) );
+ float len = light->param[VS::LIGHT_PARAM_RANGE];
+ float size = Math::tan(Math::deg2rad(light->param[VS::LIGHT_PARAM_SPOT_ANGLE])) * len;
+ return Rect3(Vector3(-size, -size, -len), Vector3(size * 2, size * 2, len));
} break;
case VS::LIGHT_OMNI: {
float r = light->param[VS::LIGHT_PARAM_RANGE];
- return Rect3( -Vector3(r,r,r), Vector3(r,r,r)*2 );
+ return Rect3(-Vector3(r, r, r), Vector3(r, r, r) * 2);
} break;
case VS::LIGHT_DIRECTIONAL: {
@@ -4584,27 +4340,27 @@ Rect3 RasterizerStorageGLES3::light_get_aabb(RID p_light) const {
default: {}
}
- ERR_FAIL_V( Rect3() );
+ ERR_FAIL_V(Rect3());
return Rect3();
}
/* PROBE API */
-RID RasterizerStorageGLES3::reflection_probe_create(){
+RID RasterizerStorageGLES3::reflection_probe_create() {
- ReflectionProbe *reflection_probe = memnew( ReflectionProbe );
+ ReflectionProbe *reflection_probe = memnew(ReflectionProbe);
- reflection_probe->intensity=1.0;
- reflection_probe->interior_ambient=Color();
- reflection_probe->interior_ambient_energy=1.0;
- reflection_probe->max_distance=0;
- reflection_probe->extents=Vector3(1,1,1);
- reflection_probe->origin_offset=Vector3(0,0,0);
- reflection_probe->interior=false;
- reflection_probe->box_projection=false;
- reflection_probe->enable_shadows=false;
- reflection_probe->cull_mask=(1<<20)-1;
- reflection_probe->update_mode=VS::REFLECTION_PROBE_UPDATE_ONCE;
+ reflection_probe->intensity = 1.0;
+ reflection_probe->interior_ambient = Color();
+ reflection_probe->interior_ambient_energy = 1.0;
+ reflection_probe->max_distance = 0;
+ reflection_probe->extents = Vector3(1, 1, 1);
+ reflection_probe->origin_offset = Vector3(0, 0, 0);
+ reflection_probe->interior = false;
+ reflection_probe->box_projection = false;
+ reflection_probe->enable_shadows = false;
+ reflection_probe->cull_mask = (1 << 20) - 1;
+ reflection_probe->update_mode = VS::REFLECTION_PROBE_UPDATE_ONCE;
return reflection_probe_owner.make_rid(reflection_probe);
}
@@ -4614,9 +4370,8 @@ void RasterizerStorageGLES3::reflection_probe_set_update_mode(RID p_probe, VS::R
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->update_mode=p_mode;
+ reflection_probe->update_mode = p_mode;
reflection_probe->instance_change_notify();
-
}
void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
@@ -4624,17 +4379,15 @@ void RasterizerStorageGLES3::reflection_probe_set_intensity(RID p_probe, float p
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->intensity=p_intensity;
-
+ reflection_probe->intensity = p_intensity;
}
-void RasterizerStorageGLES3::reflection_probe_set_interior_ambient(RID p_probe, const Color& p_ambient) {
+void RasterizerStorageGLES3::reflection_probe_set_interior_ambient(RID p_probe, const Color &p_ambient) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->interior_ambient=p_ambient;
-
+ reflection_probe->interior_ambient = p_ambient;
}
void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy) {
@@ -4642,8 +4395,7 @@ void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_energy(RID p_
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->interior_ambient_energy=p_energy;
-
+ reflection_probe->interior_ambient_energy = p_energy;
}
void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib) {
@@ -4651,91 +4403,80 @@ void RasterizerStorageGLES3::reflection_probe_set_interior_ambient_probe_contrib
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->interior_ambient_probe_contrib=p_contrib;
-
+ reflection_probe->interior_ambient_probe_contrib = p_contrib;
}
-
-void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance){
+void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->max_distance=p_distance;
+ reflection_probe->max_distance = p_distance;
reflection_probe->instance_change_notify();
-
}
-void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3& p_extents){
+void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->extents=p_extents;
+ reflection_probe->extents = p_extents;
reflection_probe->instance_change_notify();
-
}
-void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset){
+void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->origin_offset=p_offset;
+ reflection_probe->origin_offset = p_offset;
reflection_probe->instance_change_notify();
-
}
-void RasterizerStorageGLES3::reflection_probe_set_as_interior(RID p_probe, bool p_enable){
+void RasterizerStorageGLES3::reflection_probe_set_as_interior(RID p_probe, bool p_enable) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->interior=p_enable;
-
+ reflection_probe->interior = p_enable;
}
-void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable){
+void RasterizerStorageGLES3::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->box_projection=p_enable;
-
+ reflection_probe->box_projection = p_enable;
}
-void RasterizerStorageGLES3::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable){
+void RasterizerStorageGLES3::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->enable_shadows=p_enable;
+ reflection_probe->enable_shadows = p_enable;
reflection_probe->instance_change_notify();
-
}
-void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers){
+void RasterizerStorageGLES3::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) {
ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!reflection_probe);
- reflection_probe->cull_mask=p_layers;
+ reflection_probe->cull_mask = p_layers;
reflection_probe->instance_change_notify();
-
}
Rect3 RasterizerStorageGLES3::reflection_probe_get_aabb(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,Rect3());
+ ERR_FAIL_COND_V(!reflection_probe, Rect3());
Rect3 aabb;
- aabb.pos=-reflection_probe->extents;
- aabb.size=reflection_probe->extents*2.0;
+ aabb.pos = -reflection_probe->extents;
+ aabb.size = reflection_probe->extents * 2.0;
return aabb;
-
-
}
-VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_update_mode(RID p_probe) const{
+VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_update_mode(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,VS::REFLECTION_PROBE_UPDATE_ALWAYS);
+ ERR_FAIL_COND_V(!reflection_probe, VS::REFLECTION_PROBE_UPDATE_ALWAYS);
return reflection_probe->update_mode;
}
@@ -4743,60 +4484,51 @@ VS::ReflectionProbeUpdateMode RasterizerStorageGLES3::reflection_probe_get_updat
uint32_t RasterizerStorageGLES3::reflection_probe_get_cull_mask(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,0);
+ ERR_FAIL_COND_V(!reflection_probe, 0);
return reflection_probe->cull_mask;
-
}
Vector3 RasterizerStorageGLES3::reflection_probe_get_extents(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,Vector3());
+ ERR_FAIL_COND_V(!reflection_probe, Vector3());
return reflection_probe->extents;
-
}
-Vector3 RasterizerStorageGLES3::reflection_probe_get_origin_offset(RID p_probe) const{
+Vector3 RasterizerStorageGLES3::reflection_probe_get_origin_offset(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,Vector3());
+ ERR_FAIL_COND_V(!reflection_probe, Vector3());
return reflection_probe->origin_offset;
-
}
bool RasterizerStorageGLES3::reflection_probe_renders_shadows(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,false);
+ ERR_FAIL_COND_V(!reflection_probe, false);
return reflection_probe->enable_shadows;
-
}
-float RasterizerStorageGLES3::reflection_probe_get_origin_max_distance(RID p_probe) const{
+float RasterizerStorageGLES3::reflection_probe_get_origin_max_distance(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!reflection_probe,0);
+ ERR_FAIL_COND_V(!reflection_probe, 0);
return reflection_probe->max_distance;
-
}
/* ROOM API */
-RID RasterizerStorageGLES3::room_create(){
+RID RasterizerStorageGLES3::room_create() {
return RID();
}
-void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform){
-
-
+void RasterizerStorageGLES3::room_add_bounds(RID p_room, const PoolVector<Vector2> &p_convex_polygon, float p_height, const Transform &p_transform) {
}
-void RasterizerStorageGLES3::room_clear_bounds(RID p_room){
-
-
+void RasterizerStorageGLES3::room_clear_bounds(RID p_room) {
}
/* PORTAL API */
@@ -4804,67 +4536,59 @@ void RasterizerStorageGLES3::room_clear_bounds(RID p_room){
// portals are only (x/y) points, forming a convex shape, which its clockwise
// order points outside. (z is 0);
-RID RasterizerStorageGLES3::portal_create(){
+RID RasterizerStorageGLES3::portal_create() {
return RID();
}
-void RasterizerStorageGLES3::portal_set_shape(RID p_portal, const Vector<Point2>& p_shape){
-
-
+void RasterizerStorageGLES3::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape) {
}
-void RasterizerStorageGLES3::portal_set_enabled(RID p_portal, bool p_enabled){
-
-
+void RasterizerStorageGLES3::portal_set_enabled(RID p_portal, bool p_enabled) {
}
-void RasterizerStorageGLES3::portal_set_disable_distance(RID p_portal, float p_distance){
-
-
+void RasterizerStorageGLES3::portal_set_disable_distance(RID p_portal, float p_distance) {
}
-void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color& p_color){
-
-
+void RasterizerStorageGLES3::portal_set_disabled_color(RID p_portal, const Color &p_color) {
}
RID RasterizerStorageGLES3::gi_probe_create() {
- GIProbe *gip = memnew( GIProbe );
+ GIProbe *gip = memnew(GIProbe);
- gip->bounds=Rect3(Vector3(),Vector3(1,1,1));
- gip->dynamic_range=1.0;
- gip->energy=1.0;
- gip->propagation=1.0;
- gip->bias=0.4;
- gip->interior=false;
- gip->compress=false;
- gip->version=1;
- gip->cell_size=1.0;
+ gip->bounds = Rect3(Vector3(), Vector3(1, 1, 1));
+ gip->dynamic_range = 1.0;
+ gip->energy = 1.0;
+ gip->propagation = 1.0;
+ gip->bias = 0.4;
+ gip->interior = false;
+ gip->compress = false;
+ gip->version = 1;
+ gip->cell_size = 1.0;
return gi_probe_owner.make_rid(gip);
}
-void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds){
+void RasterizerStorageGLES3::gi_probe_set_bounds(RID p_probe, const Rect3 &p_bounds) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->bounds=p_bounds;
+ gip->bounds = p_bounds;
gip->version++;
gip->instance_change_notify();
}
-Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const{
+Rect3 RasterizerStorageGLES3::gi_probe_get_bounds(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,Rect3());
+ ERR_FAIL_COND_V(!gip, Rect3());
return gip->bounds;
}
-void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe,float p_size) {
+void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe, float p_size) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->cell_size=p_size;
+ gip->cell_size = p_size;
gip->version++;
gip->instance_change_notify();
}
@@ -4872,161 +4596,141 @@ void RasterizerStorageGLES3::gi_probe_set_cell_size(RID p_probe,float p_size) {
float RasterizerStorageGLES3::gi_probe_get_cell_size(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,0);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->cell_size;
-
}
-void RasterizerStorageGLES3::gi_probe_set_to_cell_xform(RID p_probe,const Transform& p_xform) {
+void RasterizerStorageGLES3::gi_probe_set_to_cell_xform(RID p_probe, const Transform &p_xform) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->to_cell=p_xform;
+ gip->to_cell = p_xform;
}
Transform RasterizerStorageGLES3::gi_probe_get_to_cell_xform(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,Transform());
+ ERR_FAIL_COND_V(!gip, Transform());
return gip->to_cell;
-
}
-
-
-void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe,const PoolVector<int>& p_data){
+void RasterizerStorageGLES3::gi_probe_set_dynamic_data(RID p_probe, const PoolVector<int> &p_data) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->dynamic_data=p_data;
+ gip->dynamic_data = p_data;
gip->version++;
gip->instance_change_notify();
-
}
-PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const{
+PoolVector<int> RasterizerStorageGLES3::gi_probe_get_dynamic_data(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,PoolVector<int>());
+ ERR_FAIL_COND_V(!gip, PoolVector<int>());
return gip->dynamic_data;
}
-void RasterizerStorageGLES3::gi_probe_set_dynamic_range(RID p_probe,int 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);
- gip->dynamic_range=p_range;
-
+ gip->dynamic_range = p_range;
}
-int 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);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->dynamic_range;
}
-void RasterizerStorageGLES3::gi_probe_set_energy(RID p_probe,float p_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;
-
+ gip->energy = p_range;
}
-
-void RasterizerStorageGLES3::gi_probe_set_bias(RID p_probe,float p_range){
+void RasterizerStorageGLES3::gi_probe_set_bias(RID p_probe, float p_range) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->bias=p_range;
-
+ gip->bias = p_range;
}
-void RasterizerStorageGLES3::gi_probe_set_propagation(RID p_probe,float p_range){
+void RasterizerStorageGLES3::gi_probe_set_propagation(RID p_probe, float p_range) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->propagation=p_range;
-
+ gip->propagation = p_range;
}
-void RasterizerStorageGLES3::gi_probe_set_interior(RID p_probe,bool p_enable) {
+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;
-
+ gip->interior = p_enable;
}
-bool RasterizerStorageGLES3::gi_probe_is_interior(RID p_probe) const{
+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);
+ ERR_FAIL_COND_V(!gip, false);
return gip->interior;
-
}
-
-void RasterizerStorageGLES3::gi_probe_set_compress(RID p_probe,bool p_enable) {
+void RasterizerStorageGLES3::gi_probe_set_compress(RID p_probe, bool p_enable) {
GIProbe *gip = gi_probe_owner.getornull(p_probe);
ERR_FAIL_COND(!gip);
- gip->compress=p_enable;
-
+ gip->compress = p_enable;
}
-bool RasterizerStorageGLES3::gi_probe_is_compressed(RID p_probe) const{
+bool RasterizerStorageGLES3::gi_probe_is_compressed(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,false);
+ ERR_FAIL_COND_V(!gip, false);
return gip->compress;
-
}
-float RasterizerStorageGLES3::gi_probe_get_energy(RID p_probe) const{
+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);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->energy;
}
-float RasterizerStorageGLES3::gi_probe_get_bias(RID p_probe) const{
+float RasterizerStorageGLES3::gi_probe_get_bias(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,0);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->bias;
}
-
-float RasterizerStorageGLES3::gi_probe_get_propagation(RID p_probe) const{
+float RasterizerStorageGLES3::gi_probe_get_propagation(RID p_probe) const {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,0);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->propagation;
}
-
-
-
-
uint32_t RasterizerStorageGLES3::gi_probe_get_version(RID p_probe) {
const GIProbe *gip = gi_probe_owner.getornull(p_probe);
- ERR_FAIL_COND_V(!gip,0);
+ ERR_FAIL_COND_V(!gip, 0);
return gip->version;
}
@@ -5041,39 +4745,39 @@ RasterizerStorage::GIProbeCompression RasterizerStorageGLES3::gi_probe_get_dynam
RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_height, int p_depth, GIProbeCompression p_compression) {
- GIProbeData *gipd = memnew( GIProbeData );
+ GIProbeData *gipd = memnew(GIProbeData);
- gipd->width=p_width;
- gipd->height=p_height;
- gipd->depth=p_depth;
- gipd->compression=p_compression;
+ gipd->width = p_width;
+ gipd->height = p_height;
+ gipd->depth = p_depth;
+ gipd->compression = p_compression;
glActiveTexture(GL_TEXTURE0);
- glGenTextures(1,&gipd->tex_id);
- glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
+ glGenTextures(1, &gipd->tex_id);
+ glBindTexture(GL_TEXTURE_3D, gipd->tex_id);
- int level=0;
- int min_size=1;
+ int level = 0;
+ int min_size = 1;
- if (gipd->compression==GI_PROBE_S3TC) {
- min_size=4;
+ if (gipd->compression == GI_PROBE_S3TC) {
+ min_size = 4;
}
print_line("dyndata create");
- while(true) {
+ while (true) {
- if (gipd->compression==GI_PROBE_S3TC) {
+ if (gipd->compression == GI_PROBE_S3TC) {
int size = p_width * p_height * p_depth;
- glCompressedTexImage3D(GL_TEXTURE_3D,level,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,p_width,p_height,p_depth,0, size,NULL);
+ glCompressedTexImage3D(GL_TEXTURE_3D, level, _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT, p_width, p_height, p_depth, 0, size, NULL);
} else {
- glTexImage3D(GL_TEXTURE_3D,level,GL_RGBA8,p_width,p_height,p_depth,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
+ glTexImage3D(GL_TEXTURE_3D, level, GL_RGBA8, p_width, p_height, p_depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
}
- if (p_width<=min_size || p_height<=min_size || p_depth<=min_size)
+ if (p_width <= min_size || p_height <= min_size || p_depth <= min_size)
break;
- p_width>>=1;
- p_height>>=1;
- p_depth>>=1;
+ p_width >>= 1;
+ p_height >>= 1;
+ p_depth >>= 1;
level++;
}
@@ -5085,7 +4789,7 @@ RID RasterizerStorageGLES3::gi_probe_dynamic_data_create(int p_width, int p_heig
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, level);
- gipd->levels=level+1;
+ gipd->levels = level + 1;
return gi_probe_data_owner.make_rid(gipd);
}
@@ -5094,7 +4798,7 @@ void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, i
GIProbeData *gipd = gi_probe_data_owner.getornull(p_gi_probe_data);
ERR_FAIL_COND(!gipd);
-/*
+ /*
Vector<uint8_t> data;
data.resize((gipd->width>>p_mipmap)*(gipd->height>>p_mipmap)*(gipd->depth>>p_mipmap)*4);
@@ -5113,120 +4817,109 @@ void RasterizerStorageGLES3::gi_probe_dynamic_data_update(RID p_gi_probe_data, i
}
*/
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_3D,gipd->tex_id);
- if (gipd->compression==GI_PROBE_S3TC) {
- int size = (gipd->width>>p_mipmap) * (gipd->height>>p_mipmap) * p_slice_count;
- glCompressedTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,_EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT,size, p_data);
+ glBindTexture(GL_TEXTURE_3D, gipd->tex_id);
+ if (gipd->compression == GI_PROBE_S3TC) {
+ int size = (gipd->width >> p_mipmap) * (gipd->height >> p_mipmap) * p_slice_count;
+ glCompressedTexSubImage3D(GL_TEXTURE_3D, p_mipmap, 0, 0, p_depth_slice, gipd->width >> p_mipmap, gipd->height >> p_mipmap, p_slice_count, _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT, size, p_data);
} else {
- glTexSubImage3D(GL_TEXTURE_3D,p_mipmap,0,0,p_depth_slice,gipd->width>>p_mipmap,gipd->height>>p_mipmap,p_slice_count,GL_RGBA,GL_UNSIGNED_BYTE,p_data);
+ glTexSubImage3D(GL_TEXTURE_3D, p_mipmap, 0, 0, p_depth_slice, gipd->width >> p_mipmap, gipd->height >> p_mipmap, p_slice_count, GL_RGBA, GL_UNSIGNED_BYTE, p_data);
}
//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,p_data);
//glTexImage3D(GL_TEXTURE_3D,p_mipmap,GL_RGBA8,gipd->width>>p_mipmap,gipd->height>>p_mipmap,gipd->depth>>p_mipmap,0,GL_RGBA,GL_UNSIGNED_BYTE,data.ptr());
-
}
///////
-
-
RID RasterizerStorageGLES3::particles_create() {
- Particles *particles = memnew( Particles );
-
+ Particles *particles = memnew(Particles);
return particles_owner.make_rid(particles);
}
-void RasterizerStorageGLES3::particles_set_emitting(RID p_particles,bool p_emitting) {
+void RasterizerStorageGLES3::particles_set_emitting(RID p_particles, bool p_emitting) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->emitting=p_emitting;
-
+ particles->emitting = p_emitting;
}
-void RasterizerStorageGLES3::particles_set_amount(RID p_particles,int p_amount) {
+void RasterizerStorageGLES3::particles_set_amount(RID p_particles, int p_amount) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- int floats = p_amount*24;
- float * data = memnew_arr(float,floats);
+ int floats = p_amount * 24;
+ float *data = memnew_arr(float, floats);
- for(int i=0;i<floats;i++) {
- data[i]=0;
+ for (int i = 0; i < floats; i++) {
+ data[i] = 0;
}
+ glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[0]);
+ glBufferData(GL_ARRAY_BUFFER, floats * sizeof(float), data, GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]);
- glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[1]);
+ glBufferData(GL_ARRAY_BUFFER, floats * sizeof(float), data, GL_DYNAMIC_DRAW);
- glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[1]);
- glBufferData(GL_ARRAY_BUFFER,floats*sizeof(float),data,GL_DYNAMIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ARRAY_BUFFER,0);
-
- particles->prev_ticks=0;
- particles->phase=0;
- particles->prev_phase=0;
+ particles->prev_ticks = 0;
+ particles->phase = 0;
+ particles->prev_phase = 0;
memdelete_arr(data);
-
}
-void RasterizerStorageGLES3::particles_set_lifetime(RID p_particles,float p_lifetime){
+void RasterizerStorageGLES3::particles_set_lifetime(RID p_particles, float p_lifetime) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->lifetime=p_lifetime;
+ particles->lifetime = p_lifetime;
}
-void RasterizerStorageGLES3::particles_set_pre_process_time(RID p_particles,float p_time) {
+void RasterizerStorageGLES3::particles_set_pre_process_time(RID p_particles, float p_time) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->pre_process_time=p_time;
-
+ particles->pre_process_time = p_time;
}
-void RasterizerStorageGLES3::particles_set_explosiveness_ratio(RID p_particles,float p_ratio) {
+void RasterizerStorageGLES3::particles_set_explosiveness_ratio(RID p_particles, float p_ratio) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->explosiveness=p_ratio;
+ particles->explosiveness = p_ratio;
}
-void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles,float p_ratio) {
+void RasterizerStorageGLES3::particles_set_randomness_ratio(RID p_particles, float p_ratio) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->randomness=p_ratio;
-
+ particles->randomness = p_ratio;
}
-void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb) {
+void RasterizerStorageGLES3::particles_set_custom_aabb(RID p_particles, const Rect3 &p_aabb) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->custom_aabb=p_aabb;
-
+ particles->custom_aabb = p_aabb;
}
-void RasterizerStorageGLES3::particles_set_gravity(RID p_particles,const Vector3& p_gravity) {
+void RasterizerStorageGLES3::particles_set_gravity(RID p_particles, const Vector3 &p_gravity) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->gravity=p_gravity;
-
+ particles->gravity = p_gravity;
}
-void RasterizerStorageGLES3::particles_set_use_local_coordinates(RID p_particles,bool p_enable) {
+void RasterizerStorageGLES3::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->use_local_coords=p_enable;
+ particles->use_local_coords = p_enable;
}
-void RasterizerStorageGLES3::particles_set_process_material(RID p_particles,RID p_material) {
+void RasterizerStorageGLES3::particles_set_process_material(RID p_particles, RID p_material) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->process_material=p_material;
+ particles->process_material = p_material;
}
void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape) {
@@ -5234,67 +4927,64 @@ void RasterizerStorageGLES3::particles_set_emission_shape(RID p_particles, VS::P
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->emission_shape=p_shape;
+ particles->emission_shape = p_shape;
}
-void RasterizerStorageGLES3::particles_set_emission_sphere_radius(RID p_particles,float p_radius) {
+void RasterizerStorageGLES3::particles_set_emission_sphere_radius(RID p_particles, float p_radius) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->emission_sphere_radius=p_radius;
+ particles->emission_sphere_radius = p_radius;
}
-void RasterizerStorageGLES3::particles_set_emission_box_extents(RID p_particles,const Vector3& p_extents) {
+void RasterizerStorageGLES3::particles_set_emission_box_extents(RID p_particles, const Vector3 &p_extents) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->emission_box_extents=p_extents;
+ particles->emission_box_extents = p_extents;
}
-void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles,const PoolVector<Vector3>& p_points) {
+void RasterizerStorageGLES3::particles_set_emission_points(RID p_particles, const PoolVector<Vector3> &p_points) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->emission_points=p_points;
+ particles->emission_points = p_points;
}
-
-void RasterizerStorageGLES3::particles_set_draw_order(RID p_particles,VS::ParticlesDrawOrder p_order) {
+void RasterizerStorageGLES3::particles_set_draw_order(RID p_particles, VS::ParticlesDrawOrder p_order) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- particles->draw_order=p_order;
+ particles->draw_order = p_order;
}
-void RasterizerStorageGLES3::particles_set_draw_passes(RID p_particles,int p_count) {
+void RasterizerStorageGLES3::particles_set_draw_passes(RID p_particles, int p_count) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
particles->draw_passes.resize(p_count);
}
-void RasterizerStorageGLES3::particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material) {
+void RasterizerStorageGLES3::particles_set_draw_pass_material(RID p_particles, int p_pass, RID p_material) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
- particles->draw_passes[p_pass].material=p_material;
-
+ ERR_FAIL_INDEX(p_pass, particles->draw_passes.size());
+ particles->draw_passes[p_pass].material = p_material;
}
-void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh) {
+void RasterizerStorageGLES3::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) {
Particles *particles = particles_owner.getornull(p_particles);
ERR_FAIL_COND(!particles);
- ERR_FAIL_INDEX(p_pass,particles->draw_passes.size());
- particles->draw_passes[p_pass].mesh=p_mesh;
-
+ ERR_FAIL_INDEX(p_pass, particles->draw_passes.size());
+ particles->draw_passes[p_pass].mesh = p_mesh;
}
Rect3 RasterizerStorageGLES3::particles_get_current_aabb(RID p_particles) {
const Particles *particles = particles_owner.getornull(p_particles);
- ERR_FAIL_COND_V(!particles,Rect3());
+ ERR_FAIL_COND_V(!particles, Rect3());
return particles->computed_aabb;
}
@@ -5304,122 +4994,111 @@ void RasterizerStorageGLES3::update_particles() {
glEnable(GL_RASTERIZER_DISCARD);
glBindVertexArray(0);
-
while (particle_update_list.first()) {
//use transform feedback to process particles
Particles *particles = particle_update_list.first()->self();
-
Material *material = material_owner.getornull(particles->process_material);
- if (!material || !material->shader || material->shader->mode!=VS::SHADER_PARTICLES) {
+ if (!material || !material->shader || material->shader->mode != VS::SHADER_PARTICLES) {
shaders.particles.set_custom_shader(0);
} else {
- shaders.particles.set_custom_shader( material->shader->custom_code_id );
+ shaders.particles.set_custom_shader(material->shader->custom_code_id);
if (material->ubo_id) {
- glBindBufferBase(GL_UNIFORM_BUFFER,0,material->ubo_id);
+ glBindBufferBase(GL_UNIFORM_BUFFER, 0, material->ubo_id);
}
int tc = material->textures.size();
- RID* textures = material->textures.ptr();
- ShaderLanguage::ShaderNode::Uniform::Hint* texture_hints = material->shader->texture_hints.ptr();
+ RID *textures = material->textures.ptr();
+ ShaderLanguage::ShaderNode::Uniform::Hint *texture_hints = material->shader->texture_hints.ptr();
+ for (int i = 0; i < tc; i++) {
- for(int i=0;i<tc;i++) {
-
- glActiveTexture(GL_TEXTURE0+i);
+ glActiveTexture(GL_TEXTURE0 + i);
GLenum target;
GLuint tex;
- RasterizerStorageGLES3::Texture *t = texture_owner.getornull( textures[i] );
+ RasterizerStorageGLES3::Texture *t = texture_owner.getornull(textures[i]);
if (!t) {
//check hints
- target=GL_TEXTURE_2D;
+ target = GL_TEXTURE_2D;
- switch(texture_hints[i]) {
+ switch (texture_hints[i]) {
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO:
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK: {
- tex=resources.black_tex;
+ tex = resources.black_tex;
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISO: {
- tex=resources.aniso_tex;
+ tex = resources.aniso_tex;
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
- tex=resources.normal_tex;
+ tex = resources.normal_tex;
} break;
default: {
- tex=resources.white_tex;
+ tex = resources.white_tex;
} break;
}
-
} else {
- target=t->target;
+ target = t->target;
tex = t->tex_id;
-
}
- glBindTexture(target,tex);
+ glBindTexture(target, tex);
}
-
}
shaders.particles.bind();
- shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN,particles->origin);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::ORIGIN, particles->origin);
- float new_phase = Math::fmod((float)particles->phase+(frame.delta/particles->lifetime),(float)1.0);
+ float new_phase = Math::fmod((float)particles->phase + (frame.delta / particles->lifetime), (float)1.0);
- shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE,new_phase);
- shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE,particles->phase);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::SYSTEM_PHASE, new_phase);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::PREV_SYSTEM_PHASE, particles->phase);
particles->phase = new_phase;
- shaders.particles.set_uniform(ParticlesShaderGLES3::TOTAL_PARTICLES,particles->amount);
- shaders.particles.set_uniform(ParticlesShaderGLES3::TIME,0.0);
- shaders.particles.set_uniform(ParticlesShaderGLES3::EXPLOSIVENESS,particles->explosiveness);
- shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA,frame.delta);
- shaders.particles.set_uniform(ParticlesShaderGLES3::GRAVITY,particles->gravity);
- shaders.particles.set_uniform(ParticlesShaderGLES3::ATTRACTOR_COUNT,0);
-
-
+ shaders.particles.set_uniform(ParticlesShaderGLES3::TOTAL_PARTICLES, particles->amount);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::TIME, 0.0);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::EXPLOSIVENESS, particles->explosiveness);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::DELTA, frame.delta);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::GRAVITY, particles->gravity);
+ shaders.particles.set_uniform(ParticlesShaderGLES3::ATTRACTOR_COUNT, 0);
-
- glBindBuffer(GL_ARRAY_BUFFER,particles->particle_buffers[0]);
+ glBindBuffer(GL_ARRAY_BUFFER, particles->particle_buffers[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particles->particle_buffers[1]);
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glEnableVertexAttribArray(i);
- glVertexAttribPointer(i,4,GL_FLOAT,GL_FALSE,sizeof(float)*4*6,((uint8_t*)0)+(i*16));
+ glVertexAttribPointer(i, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 4 * 6, ((uint8_t *)0) + (i * 16));
}
-
glBeginTransformFeedback(GL_POINTS);
- glDrawArrays(GL_POINTS,0,particles->amount);
+ glDrawArrays(GL_POINTS, 0, particles->amount);
glEndTransformFeedback();
particle_update_list.remove(particle_update_list.first());
- SWAP(particles->particle_buffers[0],particles->particle_buffers[1]);
+ SWAP(particles->particle_buffers[0], particles->particle_buffers[1]);
}
glDisable(GL_RASTERIZER_DISCARD);
- for(int i=0;i<6;i++) {
+ for (int i = 0; i < 6; i++) {
glDisableVertexAttribArray(i);
}
-
}
////////
-void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) {
+void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
@@ -5427,7 +5106,7 @@ void RasterizerStorageGLES3::instance_add_skeleton(RID p_skeleton,RasterizerScen
skeleton->instances.insert(p_instance);
}
-void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance) {
+void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) {
Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
ERR_FAIL_COND(!skeleton);
@@ -5435,11 +5114,10 @@ void RasterizerStorageGLES3::instance_remove_skeleton(RID p_skeleton,RasterizerS
skeleton->instances.erase(p_instance);
}
+void RasterizerStorageGLES3::instance_add_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) {
-void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance) {
-
- Instantiable *inst=NULL;
- switch(p_instance->base_type) {
+ Instantiable *inst = NULL;
+ switch (p_instance->base_type) {
case VS::INSTANCE_MESH: {
inst = mesh_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
@@ -5471,14 +5149,14 @@ void RasterizerStorageGLES3::instance_add_dependency(RID p_base,RasterizerScene:
}
}
- inst->instance_list.add( &p_instance->dependency_item );
+ inst->instance_list.add(&p_instance->dependency_item);
}
-void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance){
+void RasterizerStorageGLES3::instance_remove_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) {
- Instantiable *inst=NULL;
+ Instantiable *inst = NULL;
- switch(p_instance->base_type) {
+ switch (p_instance->base_type) {
case VS::INSTANCE_MESH: {
inst = mesh_owner.getornull(p_base);
ERR_FAIL_COND(!inst);
@@ -5513,85 +5191,76 @@ void RasterizerStorageGLES3::instance_remove_dependency(RID p_base,RasterizerSce
ERR_FAIL_COND(!inst);
- inst->instance_list.remove( &p_instance->dependency_item );
+ inst->instance_list.remove(&p_instance->dependency_item);
}
-
/* RENDER TARGET */
-
void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
-
if (rt->fbo) {
- glDeleteFramebuffers(1,&rt->fbo);
- glDeleteTextures(1,&rt->color);
- rt->fbo=0;
+ glDeleteFramebuffers(1, &rt->fbo);
+ glDeleteTextures(1, &rt->color);
+ rt->fbo = 0;
}
-
if (rt->buffers.fbo) {
- glDeleteFramebuffers(1,&rt->buffers.fbo);
- glDeleteRenderbuffers(1,&rt->buffers.depth);
- glDeleteRenderbuffers(1,&rt->buffers.diffuse);
- glDeleteRenderbuffers(1,&rt->buffers.specular);
- glDeleteRenderbuffers(1,&rt->buffers.normal_rough);
- glDeleteRenderbuffers(1,&rt->buffers.motion_sss);
- glDeleteFramebuffers(1,&rt->buffers.effect_fbo);
- glDeleteTextures(1,&rt->buffers.effect);
+ glDeleteFramebuffers(1, &rt->buffers.fbo);
+ glDeleteRenderbuffers(1, &rt->buffers.depth);
+ glDeleteRenderbuffers(1, &rt->buffers.diffuse);
+ glDeleteRenderbuffers(1, &rt->buffers.specular);
+ glDeleteRenderbuffers(1, &rt->buffers.normal_rough);
+ glDeleteRenderbuffers(1, &rt->buffers.motion_sss);
+ glDeleteFramebuffers(1, &rt->buffers.effect_fbo);
+ glDeleteTextures(1, &rt->buffers.effect);
- rt->buffers.fbo=0;
+ rt->buffers.fbo = 0;
}
-
if (rt->depth) {
- glDeleteTextures(1,&rt->depth);
- rt->depth=0;
+ glDeleteTextures(1, &rt->depth);
+ rt->depth = 0;
}
-
if (rt->effects.ssao.blur_fbo[0]) {
- glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[0]);
- glDeleteTextures(1,&rt->effects.ssao.blur_red[0]);
- glDeleteFramebuffers(1,&rt->effects.ssao.blur_fbo[1]);
- glDeleteTextures(1,&rt->effects.ssao.blur_red[1]);
- for(int i=0;i<rt->effects.ssao.depth_mipmap_fbos.size();i++) {
- glDeleteFramebuffers(1,&rt->effects.ssao.depth_mipmap_fbos[i]);
+ glDeleteFramebuffers(1, &rt->effects.ssao.blur_fbo[0]);
+ glDeleteTextures(1, &rt->effects.ssao.blur_red[0]);
+ glDeleteFramebuffers(1, &rt->effects.ssao.blur_fbo[1]);
+ glDeleteTextures(1, &rt->effects.ssao.blur_red[1]);
+ for (int i = 0; i < rt->effects.ssao.depth_mipmap_fbos.size(); i++) {
+ glDeleteFramebuffers(1, &rt->effects.ssao.depth_mipmap_fbos[i]);
}
rt->effects.ssao.depth_mipmap_fbos.clear();
- glDeleteTextures(1,&rt->effects.ssao.linear_depth);
+ glDeleteTextures(1, &rt->effects.ssao.linear_depth);
- rt->effects.ssao.blur_fbo[0]=0;
- rt->effects.ssao.blur_fbo[1]=0;
+ rt->effects.ssao.blur_fbo[0] = 0;
+ rt->effects.ssao.blur_fbo[1] = 0;
}
-
if (rt->exposure.fbo) {
- glDeleteFramebuffers(1,&rt->exposure.fbo);
- glDeleteTextures(1,&rt->exposure.color);
- rt->exposure.fbo=0;
+ glDeleteFramebuffers(1, &rt->exposure.fbo);
+ glDeleteTextures(1, &rt->exposure.color);
+ rt->exposure.fbo = 0;
}
Texture *tex = texture_owner.get(rt->texture);
- tex->alloc_height=0;
- tex->alloc_width=0;
- tex->width=0;
- tex->height=0;
-
+ tex->alloc_height = 0;
+ tex->alloc_width = 0;
+ tex->width = 0;
+ tex->height = 0;
- for(int i=0;i<2;i++) {
- for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
- glDeleteFramebuffers(1,&rt->effects.mip_maps[i].sizes[j].fbo);
+ for (int i = 0; i < 2; i++) {
+ for (int j = 0; j < rt->effects.mip_maps[i].sizes.size(); j++) {
+ glDeleteFramebuffers(1, &rt->effects.mip_maps[i].sizes[j].fbo);
}
- glDeleteTextures(1,&rt->effects.mip_maps[i].color);
+ glDeleteTextures(1, &rt->effects.mip_maps[i].color);
rt->effects.mip_maps[i].sizes.clear();
- rt->effects.mip_maps[i].levels=0;
+ rt->effects.mip_maps[i].levels = 0;
}
-
-/*
+ /*
if (rt->effects.screen_space_depth) {
glDeleteTextures(1,&rt->effects.screen_space_depth);
rt->effects.screen_space_depth=0;
@@ -5600,9 +5269,9 @@ void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
*/
}
-void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
+void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
- if (rt->width<=0 || rt->height<=0)
+ if (rt->width <= 0 || rt->height <= 0)
return;
GLuint color_internal_format;
@@ -5611,22 +5280,21 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
Image::Format image_format;
bool hdr = rt->flags[RENDER_TARGET_HDR] && config.hdr_supported;
- hdr=false;
+ hdr = false;
if (!hdr || rt->flags[RENDER_TARGET_NO_3D]) {
- color_internal_format=GL_RGBA8;
- color_format=GL_RGBA;
- color_type=GL_UNSIGNED_BYTE;
- image_format=Image::FORMAT_RGBA8;
+ color_internal_format = GL_RGBA8;
+ color_format = GL_RGBA;
+ color_type = GL_UNSIGNED_BYTE;
+ image_format = Image::FORMAT_RGBA8;
} else {
- color_internal_format=GL_RGBA16F;
- color_format=GL_RGBA;
- color_type=GL_HALF_FLOAT;
- image_format=Image::FORMAT_RGBAH;
+ color_internal_format = GL_RGBA16F;
+ color_format = GL_RGBA;
+ color_type = GL_HALF_FLOAT;
+ image_format = Image::FORMAT_RGBAH;
}
-
{
/* FRONT FBO */
@@ -5635,23 +5303,22 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glGenFramebuffers(1, &rt->fbo);
glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
-
glGenTextures(1, &rt->depth);
glBindTexture(GL_TEXTURE_2D, rt->depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, rt->width, rt->height, 0,
- GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+ GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_TEXTURE_2D, rt->depth, 0);
+ GL_TEXTURE_2D, rt->depth, 0);
glGenTextures(1, &rt->color);
glBindTexture(GL_TEXTURE_2D, rt->color);
- glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -5663,36 +5330,31 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE) {
- printf("framebuffer fail, status: %x\n",status);
+ printf("framebuffer fail, status: %x\n", status);
}
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
Texture *tex = texture_owner.get(rt->texture);
- tex->format=image_format;
- tex->gl_format_cache=color_format;
- tex->gl_type_cache=color_type;
- tex->gl_internal_format_cache=color_internal_format;
- tex->tex_id=rt->color;
- tex->width=rt->width;
- tex->alloc_width=rt->width;
- tex->height=rt->height;
- tex->alloc_height=rt->height;
-
-
- texture_set_flags(rt->texture,tex->flags);
+ tex->format = image_format;
+ tex->gl_format_cache = color_format;
+ tex->gl_type_cache = color_type;
+ tex->gl_internal_format_cache = color_internal_format;
+ tex->tex_id = rt->color;
+ tex->width = rt->width;
+ tex->alloc_width = rt->width;
+ tex->height = rt->height;
+ tex->alloc_height = rt->height;
+ texture_set_flags(rt->texture, tex->flags);
}
-
/* BACK FBO */
- if (config.render_arch==RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) {
-
-
+ if (config.render_arch == RENDER_ARCH_DESKTOP && !rt->flags[RENDER_TARGET_NO_3D]) {
- static const int msaa_value[]={0,2,4,8,16};
- int msaa=msaa_value[rt->msaa];
+ static const int msaa_value[] = { 0, 2, 4, 8, 16 };
+ int msaa = msaa_value[rt->msaa];
//regular fbo
glGenFramebuffers(1, &rt->buffers.fbo);
@@ -5700,66 +5362,63 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glGenRenderbuffers(1, &rt->buffers.depth);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.depth);
- if (msaa==0)
- glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH24_STENCIL8,rt->width,rt->height);
+ if (msaa == 0)
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, rt->width, rt->height);
else
- glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_DEPTH24_STENCIL8,rt->width,rt->height);
+ glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_DEPTH24_STENCIL8, rt->width, rt->height);
+
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->buffers.depth);
- glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER,rt->buffers.depth);
-
glGenRenderbuffers(1, &rt->buffers.diffuse);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.diffuse);
- if (msaa==0)
- glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height);
+ if (msaa == 0)
+ glRenderbufferStorage(GL_RENDERBUFFER, color_internal_format, rt->width, rt->height);
else
- glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height);
+ glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, color_internal_format, rt->width, rt->height);
- glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER,rt->buffers.diffuse);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rt->buffers.diffuse);
glGenRenderbuffers(1, &rt->buffers.specular);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.specular);
- if (msaa==0)
- glRenderbufferStorage(GL_RENDERBUFFER,color_internal_format,rt->width,rt->height);
+ if (msaa == 0)
+ glRenderbufferStorage(GL_RENDERBUFFER, color_internal_format, rt->width, rt->height);
else
- glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,color_internal_format,rt->width,rt->height);
+ glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, color_internal_format, rt->width, rt->height);
- glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT1,GL_RENDERBUFFER,rt->buffers.specular);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, rt->buffers.specular);
glGenRenderbuffers(1, &rt->buffers.normal_rough);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.normal_rough);
- if (msaa==0)
- glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height);
+ if (msaa == 0)
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, rt->width, rt->height);
else
- glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height);
-
- glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT2,GL_RENDERBUFFER,rt->buffers.normal_rough);
+ glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_RGBA8, rt->width, rt->height);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_RENDERBUFFER, rt->buffers.normal_rough);
glGenRenderbuffers(1, &rt->buffers.motion_sss);
glBindRenderbuffer(GL_RENDERBUFFER, rt->buffers.motion_sss);
- if (msaa==0)
- glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA8,rt->width,rt->height);
+ if (msaa == 0)
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, rt->width, rt->height);
else
- glRenderbufferStorageMultisample(GL_RENDERBUFFER,msaa,GL_RGBA8,rt->width,rt->height);
-
- glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT3,GL_RENDERBUFFER,rt->buffers.motion_sss);
-
+ glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, GL_RGBA8, rt->width, rt->height);
+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_RENDERBUFFER, rt->buffers.motion_sss);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE) {
- printf("err status: %x\n",status);
+ printf("err status: %x\n", status);
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
- }
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
+ }
- glBindRenderbuffer(GL_RENDERBUFFER,0);
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
// effect resolver
@@ -5769,92 +5428,84 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glGenTextures(1, &rt->buffers.effect);
glBindTexture(GL_TEXTURE_2D, rt->buffers.effect);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, rt->width, rt->height, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D, rt->buffers.effect, 0);
-
+ GL_TEXTURE_2D, rt->buffers.effect, 0);
if (status != GL_FRAMEBUFFER_COMPLETE) {
- printf("err status: %x\n",status);
+ printf("err status: %x\n", status);
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
}
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
if (status != GL_FRAMEBUFFER_COMPLETE) {
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
}
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
- ERR_FAIL_COND( rt->effects.mip_maps[i].sizes.size() );
- int w=rt->width;
- int h=rt->height;
+ ERR_FAIL_COND(rt->effects.mip_maps[i].sizes.size());
+ int w = rt->width;
+ int h = rt->height;
-
- if (i>0) {
- w>>=1;
- h>>=1;
+ if (i > 0) {
+ w >>= 1;
+ h >>= 1;
}
-
glGenTextures(1, &rt->effects.mip_maps[i].color);
glBindTexture(GL_TEXTURE_2D, rt->effects.mip_maps[i].color);
- int level=0;
+ int level = 0;
- while(true) {
+ while (true) {
RenderTarget::Effects::MipMaps::Size mm;
- glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL);
- mm.width=w;
- mm.height=h;
+ glTexImage2D(GL_TEXTURE_2D, level, color_internal_format, w, h, 0, color_format, color_type, NULL);
+ mm.width = w;
+ mm.height = h;
rt->effects.mip_maps[i].sizes.push_back(mm);
- w>>=1;
- h>>=1;
+ w >>= 1;
+ h >>= 1;
- if (w<2 || h<2)
+ if (w < 2 || h < 2)
break;
level++;
-
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level);
+ for (int j = 0; j < rt->effects.mip_maps[i].sizes.size(); j++) {
- for(int j=0;j<rt->effects.mip_maps[i].sizes.size();j++) {
-
- RenderTarget::Effects::MipMaps::Size &mm=rt->effects.mip_maps[i].sizes[j];
+ RenderTarget::Effects::MipMaps::Size &mm = rt->effects.mip_maps[i].sizes[j];
glGenFramebuffers(1, &mm.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, mm.fbo);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,rt->effects.mip_maps[i].color ,j);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->effects.mip_maps[i].color, j);
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
}
-
- float zero[4]={1,0,1,0};
- glClearBufferfv(GL_COLOR,0,zero);
-
-
+ float zero[4] = { 1, 0, 1, 0 };
+ glClearBufferfv(GL_COLOR, 0, zero);
}
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
- rt->effects.mip_maps[i].levels=level;
+ rt->effects.mip_maps[i].levels = level;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
@@ -5862,23 +5513,21 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-
}
///////////////// ssao
//AO strength textures
- for(int i=0;i<2;i++) {
+ for (int i = 0; i < 2; i++) {
glGenFramebuffers(1, &rt->effects.ssao.blur_fbo[i]);
glBindFramebuffer(GL_FRAMEBUFFER, rt->effects.ssao.blur_fbo[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_TEXTURE_2D, rt->depth, 0);
+ GL_TEXTURE_2D, rt->depth, 0);
glGenTextures(1, &rt->effects.ssao.blur_red[i]);
glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.blur_red[i]);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, rt->width, rt->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, rt->width, rt->height, 0, GL_RED, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -5889,24 +5538,22 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
}
-
}
//5 mip levels for depth texture, but base is read separately
glGenTextures(1, &rt->effects.ssao.linear_depth);
glBindTexture(GL_TEXTURE_2D, rt->effects.ssao.linear_depth);
- int ssao_w=rt->width/2;
- int ssao_h=rt->height/2;
+ int ssao_w = rt->width / 2;
+ int ssao_h = rt->height / 2;
+ for (int i = 0; i < 4; i++) { //5, but 4 mips, base is read directly to save bw
- for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw
-
- glTexImage2D(GL_TEXTURE_2D, i, GL_R16UI, ssao_w, ssao_h, 0, GL_RED_INTEGER, GL_UNSIGNED_SHORT, NULL);
- ssao_w>>=1;
- ssao_h>>=1;
+ glTexImage2D(GL_TEXTURE_2D, i, GL_R16UI, ssao_w, ssao_h, 0, GL_RED_INTEGER, GL_UNSIGNED_SHORT, NULL);
+ ssao_w >>= 1;
+ ssao_h >>= 1;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -5916,7 +5563,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3);
- for(int i=0;i<4;i++) { //5, but 4 mips, base is read directly to save bw
+ for (int i = 0; i < 4; i++) { //5, but 4 mips, base is read directly to save bw
GLuint fbo;
glGenFramebuffers(1, &fbo);
@@ -5925,7 +5572,6 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
rt->effects.ssao.depth_mipmap_fbos.push_back(fbo);
}
-
//////Exposure
glGenFramebuffers(1, &rt->exposure.fbo);
@@ -5933,82 +5579,77 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt){
glGenTextures(1, &rt->exposure.color);
glBindTexture(GL_TEXTURE_2D, rt->exposure.color);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 1, 1, 0, GL_RED, GL_FLOAT, NULL);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->exposure.color, 0);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 1, 1, 0, GL_RED, GL_FLOAT, NULL);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->exposure.color, 0);
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE) {
_render_target_clear(rt);
- ERR_FAIL_COND( status != GL_FRAMEBUFFER_COMPLETE );
+ ERR_FAIL_COND(status != GL_FRAMEBUFFER_COMPLETE);
}
-
}
}
+RID RasterizerStorageGLES3::render_target_create() {
-RID RasterizerStorageGLES3::render_target_create(){
-
- RenderTarget *rt = memnew( RenderTarget );
+ RenderTarget *rt = memnew(RenderTarget);
- Texture * t = memnew( Texture );
+ Texture *t = memnew(Texture);
- t->flags=0;
- t->width=0;
- t->height=0;
- t->alloc_height=0;
- t->alloc_width=0;
- t->format=Image::FORMAT_R8;
- t->target=GL_TEXTURE_2D;
- t->gl_format_cache=0;
- t->gl_internal_format_cache=0;
- t->gl_type_cache=0;
- t->data_size=0;
- t->compressed=false;
- t->srgb=false;
- t->total_data_size=0;
- t->ignore_mipmaps=false;
- t->mipmaps=0;
- t->active=true;
- t->tex_id=0;
+ t->flags = 0;
+ t->width = 0;
+ t->height = 0;
+ t->alloc_height = 0;
+ t->alloc_width = 0;
+ t->format = Image::FORMAT_R8;
+ t->target = GL_TEXTURE_2D;
+ t->gl_format_cache = 0;
+ t->gl_internal_format_cache = 0;
+ t->gl_type_cache = 0;
+ t->data_size = 0;
+ t->compressed = false;
+ t->srgb = false;
+ t->total_data_size = 0;
+ t->ignore_mipmaps = false;
+ t->mipmaps = 0;
+ t->active = true;
+ t->tex_id = 0;
-
- rt->texture=texture_owner.make_rid(t);
+ rt->texture = texture_owner.make_rid(t);
return render_target_owner.make_rid(rt);
}
-void RasterizerStorageGLES3::render_target_set_size(RID p_render_target,int p_width, int p_height){
+void RasterizerStorageGLES3::render_target_set_size(RID p_render_target, int p_width, int p_height) {
RenderTarget *rt = render_target_owner.getornull(p_render_target);
ERR_FAIL_COND(!rt);
- if (rt->width==p_width && rt->height==p_height)
+ if (rt->width == p_width && rt->height == p_height)
return;
_render_target_clear(rt);
- rt->width=p_width;
- rt->height=p_height;
+ rt->width = p_width;
+ rt->height = p_height;
_render_target_allocate(rt);
-
}
-
-RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) const{
+RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) const {
RenderTarget *rt = render_target_owner.getornull(p_render_target);
- ERR_FAIL_COND_V(!rt,RID());
+ ERR_FAIL_COND_V(!rt, RID());
return rt->texture;
}
-void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target,RenderTargetFlags p_flag,bool p_value) {
+void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) {
RenderTarget *rt = render_target_owner.getornull(p_render_target);
ERR_FAIL_COND(!rt);
- rt->flags[p_flag]=p_value;
+ rt->flags[p_flag] = p_value;
- switch(p_flag) {
+ switch (p_flag) {
case RENDER_TARGET_NO_3D:
case RENDER_TARGET_TRANSPARENT: {
//must reset for these formats
@@ -6020,36 +5661,34 @@ void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target,RenderTa
}
}
-bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target){
+bool RasterizerStorageGLES3::render_target_renedered_in_frame(RID p_render_target) {
return false;
}
-void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target,VS::ViewportMSAA p_msaa) {
+void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target, VS::ViewportMSAA p_msaa) {
RenderTarget *rt = render_target_owner.getornull(p_render_target);
ERR_FAIL_COND(!rt);
- if (rt->msaa==p_msaa)
+ if (rt->msaa == p_msaa)
return;
_render_target_clear(rt);
- rt->msaa=p_msaa;
+ rt->msaa = p_msaa;
_render_target_allocate(rt);
-
}
/* CANVAS SHADOW */
-
RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
- CanvasLightShadow *cls = memnew( CanvasLightShadow );
- if (p_width>config.max_texture_size)
- p_width=config.max_texture_size;
+ CanvasLightShadow *cls = memnew(CanvasLightShadow);
+ if (p_width > config.max_texture_size)
+ p_width = config.max_texture_size;
- cls->size=p_width;
- cls->height=16;
+ cls->size = p_width;
+ cls->height = 16;
glActiveTexture(GL_TEXTURE0);
@@ -6057,12 +5696,12 @@ RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
glGenRenderbuffers(1, &cls->depth);
- glBindRenderbuffer(GL_RENDERBUFFER, cls->depth );
- glRenderbufferStorage(GL_RENDERBUFFER,GL_DEPTH_COMPONENT24, cls->size, cls->height);
+ glBindRenderbuffer(GL_RENDERBUFFER, cls->depth);
+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, cls->size, cls->height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, cls->depth);
- glBindRenderbuffer(GL_RENDERBUFFER, 0 );
+ glBindRenderbuffer(GL_RENDERBUFFER, 0);
- glGenTextures(1,&cls->distance);
+ glGenTextures(1, &cls->distance);
glBindTexture(GL_TEXTURE_2D, cls->distance);
if (config.use_rgba_2d_shadows) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, cls->size, cls->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
@@ -6070,139 +5709,124 @@ RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, cls->size, cls->height, 0, GL_RED, GL_FLOAT, NULL);
}
-
-
-
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, cls->distance, 0);
-
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
//printf("errnum: %x\n",status);
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
- ERR_FAIL_COND_V( status != GL_FRAMEBUFFER_COMPLETE, RID() );
+ ERR_FAIL_COND_V(status != GL_FRAMEBUFFER_COMPLETE, RID());
return canvas_light_shadow_owner.make_rid(cls);
}
/* LIGHT SHADOW MAPPING */
-
RID RasterizerStorageGLES3::canvas_light_occluder_create() {
- CanvasOccluder *co = memnew( CanvasOccluder );
- co->index_id=0;
- co->vertex_id=0;
- co->len=0;
+ CanvasOccluder *co = memnew(CanvasOccluder);
+ co->index_id = 0;
+ co->vertex_id = 0;
+ co->len = 0;
return canvas_occluder_owner.make_rid(co);
}
-void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2>& p_lines) {
+void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2> &p_lines) {
CanvasOccluder *co = canvas_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!co);
- co->lines=p_lines;
+ co->lines = p_lines;
- if (p_lines.size()!=co->len) {
+ if (p_lines.size() != co->len) {
if (co->index_id)
- glDeleteBuffers(1,&co->index_id);
+ glDeleteBuffers(1, &co->index_id);
if (co->vertex_id)
- glDeleteBuffers(1,&co->vertex_id);
-
- co->index_id=0;
- co->vertex_id=0;
- co->len=0;
+ glDeleteBuffers(1, &co->vertex_id);
+ co->index_id = 0;
+ co->vertex_id = 0;
+ co->len = 0;
}
if (p_lines.size()) {
-
-
PoolVector<float> geometry;
PoolVector<uint16_t> indices;
int lc = p_lines.size();
- geometry.resize(lc*6);
- indices.resize(lc*3);
+ geometry.resize(lc * 6);
+ indices.resize(lc * 3);
- PoolVector<float>::Write vw=geometry.write();
- PoolVector<uint16_t>::Write iw=indices.write();
+ PoolVector<float>::Write vw = geometry.write();
+ PoolVector<uint16_t>::Write iw = indices.write();
-
- PoolVector<Vector2>::Read lr=p_lines.read();
+ PoolVector<Vector2>::Read lr = p_lines.read();
const int POLY_HEIGHT = 16384;
- for(int i=0;i<lc/2;i++) {
-
- vw[i*12+0]=lr[i*2+0].x;
- vw[i*12+1]=lr[i*2+0].y;
- vw[i*12+2]=POLY_HEIGHT;
+ for (int i = 0; i < lc / 2; i++) {
- vw[i*12+3]=lr[i*2+1].x;
- vw[i*12+4]=lr[i*2+1].y;
- vw[i*12+5]=POLY_HEIGHT;
+ vw[i * 12 + 0] = lr[i * 2 + 0].x;
+ vw[i * 12 + 1] = lr[i * 2 + 0].y;
+ vw[i * 12 + 2] = POLY_HEIGHT;
- vw[i*12+6]=lr[i*2+1].x;
- vw[i*12+7]=lr[i*2+1].y;
- vw[i*12+8]=-POLY_HEIGHT;
+ vw[i * 12 + 3] = lr[i * 2 + 1].x;
+ vw[i * 12 + 4] = lr[i * 2 + 1].y;
+ vw[i * 12 + 5] = POLY_HEIGHT;
- vw[i*12+9]=lr[i*2+0].x;
- vw[i*12+10]=lr[i*2+0].y;
- vw[i*12+11]=-POLY_HEIGHT;
+ vw[i * 12 + 6] = lr[i * 2 + 1].x;
+ vw[i * 12 + 7] = lr[i * 2 + 1].y;
+ vw[i * 12 + 8] = -POLY_HEIGHT;
- iw[i*6+0]=i*4+0;
- iw[i*6+1]=i*4+1;
- iw[i*6+2]=i*4+2;
+ vw[i * 12 + 9] = lr[i * 2 + 0].x;
+ vw[i * 12 + 10] = lr[i * 2 + 0].y;
+ vw[i * 12 + 11] = -POLY_HEIGHT;
- iw[i*6+3]=i*4+2;
- iw[i*6+4]=i*4+3;
- iw[i*6+5]=i*4+0;
+ iw[i * 6 + 0] = i * 4 + 0;
+ iw[i * 6 + 1] = i * 4 + 1;
+ iw[i * 6 + 2] = i * 4 + 2;
+ iw[i * 6 + 3] = i * 4 + 2;
+ iw[i * 6 + 4] = i * 4 + 3;
+ iw[i * 6 + 5] = i * 4 + 0;
}
//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
-
if (!co->vertex_id) {
- glGenBuffers(1,&co->vertex_id);
- glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
- glBufferData(GL_ARRAY_BUFFER,lc*6*sizeof(real_t),vw.ptr(),GL_STATIC_DRAW);
+ glGenBuffers(1, &co->vertex_id);
+ glBindBuffer(GL_ARRAY_BUFFER, co->vertex_id);
+ glBufferData(GL_ARRAY_BUFFER, lc * 6 * sizeof(real_t), vw.ptr(), GL_STATIC_DRAW);
} else {
- glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
- glBufferSubData(GL_ARRAY_BUFFER,0,lc*6*sizeof(real_t),vw.ptr());
-
+ glBindBuffer(GL_ARRAY_BUFFER, co->vertex_id);
+ glBufferSubData(GL_ARRAY_BUFFER, 0, lc * 6 * sizeof(real_t), vw.ptr());
}
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
if (!co->index_id) {
- glGenBuffers(1,&co->index_id);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER,lc*3*sizeof(uint16_t),iw.ptr(),GL_STATIC_DRAW);
+ glGenBuffers(1, &co->index_id);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, co->index_id);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, lc * 3 * sizeof(uint16_t), iw.ptr(), GL_STATIC_DRAW);
} else {
-
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
- glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,lc*3*sizeof(uint16_t),iw.ptr());
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, co->index_id);
+ glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, lc * 3 * sizeof(uint16_t), iw.ptr());
}
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
-
- co->len=lc;
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //unbind
+ co->len = lc;
}
-
}
VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
@@ -6234,13 +5858,13 @@ VS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
return VS::INSTANCE_NONE;
}
-bool RasterizerStorageGLES3::free(RID p_rid){
+bool RasterizerStorageGLES3::free(RID p_rid) {
if (render_target_owner.owns(p_rid)) {
RenderTarget *rt = render_target_owner.getornull(p_rid);
_render_target_clear(rt);
- Texture *t=texture_owner.get(rt->texture);
+ Texture *t = texture_owner.get(rt->texture);
texture_owner.free(rt->texture);
memdelete(t);
render_target_owner.free(p_rid);
@@ -6249,14 +5873,14 @@ bool RasterizerStorageGLES3::free(RID p_rid){
} else if (texture_owner.owns(p_rid)) {
// delete the texture
Texture *texture = texture_owner.get(p_rid);
- ERR_FAIL_COND_V(texture->render_target,true); //cant free the render target texture, dude
- info.texture_mem-=texture->total_data_size;
+ ERR_FAIL_COND_V(texture->render_target, true); //cant free the render target texture, dude
+ info.texture_mem -= texture->total_data_size;
texture_owner.free(p_rid);
memdelete(texture);
} else if (skybox_owner.owns(p_rid)) {
// delete the skybox
SkyBox *skybox = skybox_owner.get(p_rid);
- skybox_set_texture(p_rid,RID(),256);
+ skybox_set_texture(p_rid, RID(), 256);
skybox_owner.free(p_rid);
memdelete(skybox);
@@ -6265,7 +5889,6 @@ bool RasterizerStorageGLES3::free(RID p_rid){
// delete the texture
Shader *shader = shader_owner.get(p_rid);
-
if (shader->shader)
shader->shader->free_custom_shader(shader->custom_code_id);
@@ -6276,10 +5899,10 @@ bool RasterizerStorageGLES3::free(RID p_rid){
Material *mat = shader->materials.first()->self();
- mat->shader=NULL;
+ mat->shader = NULL;
_material_make_dirty(mat);
- shader->materials.remove( shader->materials.first() );
+ shader->materials.remove(shader->materials.first());
}
//material_shader.free_custom_shader(shader->custom_code_id);
@@ -6292,31 +5915,30 @@ bool RasterizerStorageGLES3::free(RID p_rid){
Material *material = material_owner.get(p_rid);
if (material->shader) {
- material->shader->materials.remove( & material->list );
+ material->shader->materials.remove(&material->list);
}
if (material->ubo_id) {
- glDeleteBuffers(1,&material->ubo_id);
+ glDeleteBuffers(1, &material->ubo_id);
}
//remove from owners
- for (Map<Geometry*,int>::Element *E=material->geometry_owners.front();E;E=E->next()) {
+ for (Map<Geometry *, int>::Element *E = material->geometry_owners.front(); E; E = E->next()) {
Geometry *g = E->key();
- g->material=RID();
+ g->material = RID();
}
- for (Map<RasterizerScene::InstanceBase*,int>::Element *E=material->instance_owners.front();E;E=E->next()) {
- RasterizerScene::InstanceBase*ins=E->key();
- if (ins->material_override==p_rid) {
- ins->material_override=RID();
+ for (Map<RasterizerScene::InstanceBase *, int>::Element *E = material->instance_owners.front(); E; E = E->next()) {
+ RasterizerScene::InstanceBase *ins = E->key();
+ if (ins->material_override == p_rid) {
+ ins->material_override = RID();
}
- for(int i=0;i<ins->materials.size();i++) {
- if (ins->materials[i]==p_rid) {
- ins->materials[i]=RID();
+ for (int i = 0; i < ins->materials.size(); i++) {
+ if (ins->materials[i] == p_rid) {
+ ins->materials[i] = RID();
}
}
-
}
material_owner.free(p_rid);
@@ -6330,11 +5952,11 @@ bool RasterizerStorageGLES3::free(RID p_rid){
skeleton_update_list.remove(&skeleton->update_list);
}
- for (Set<RasterizerScene::InstanceBase*>::Element *E=skeleton->instances.front();E;E=E->next()) {
- E->get()->skeleton=RID();
+ for (Set<RasterizerScene::InstanceBase *>::Element *E = skeleton->instances.front(); E; E = E->next()) {
+ E->get()->skeleton = RID();
}
- skeleton_allocate(p_rid,0,false);
+ skeleton_allocate(p_rid, 0, false);
skeleton_owner.free(p_rid);
memdelete(skeleton);
@@ -6345,16 +5967,15 @@ bool RasterizerStorageGLES3::free(RID p_rid){
mesh->instance_remove_deps();
mesh_clear(p_rid);
- while(mesh->multimeshes.first()) {
+ while (mesh->multimeshes.first()) {
MultiMesh *multimesh = mesh->multimeshes.first()->self();
- multimesh->mesh=RID();
- multimesh->dirty_aabb=true;
+ multimesh->mesh = RID();
+ multimesh->dirty_aabb = true;
mesh->multimeshes.remove(mesh->multimeshes.first());
if (!multimesh->update_list.in_list()) {
multimesh_update_list.add(&multimesh->update_list);
}
-
}
mesh_owner.free(p_rid);
@@ -6373,10 +5994,9 @@ bool RasterizerStorageGLES3::free(RID p_rid){
}
}
- multimesh_allocate(p_rid,0,VS::MULTIMESH_TRANSFORM_2D,VS::MULTIMESH_COLOR_NONE); //frees multimesh
+ multimesh_allocate(p_rid, 0, VS::MULTIMESH_TRANSFORM_2D, VS::MULTIMESH_COLOR_NONE); //frees multimesh
update_dirty_multimeshes();
-
multimesh_owner.free(p_rid);
memdelete(multimesh);
} else if (immediate_owner.owns(p_rid)) {
@@ -6409,7 +6029,6 @@ bool RasterizerStorageGLES3::free(RID p_rid){
// delete the texture
GIProbe *gi_probe = gi_probe_owner.get(p_rid);
-
gi_probe_owner.free(p_rid);
memdelete(gi_probe);
} else if (gi_probe_data_owner.owns(p_rid)) {
@@ -6418,18 +6037,17 @@ bool RasterizerStorageGLES3::free(RID p_rid){
GIProbeData *gi_probe_data = gi_probe_data_owner.get(p_rid);
print_line("dyndata delete");
- glDeleteTextures(1,&gi_probe_data->tex_id);
+ glDeleteTextures(1, &gi_probe_data->tex_id);
gi_probe_owner.free(p_rid);
memdelete(gi_probe_data);
} else if (canvas_occluder_owner.owns(p_rid)) {
-
CanvasOccluder *co = canvas_occluder_owner.get(p_rid);
if (co->index_id)
- glDeleteBuffers(1,&co->index_id);
+ glDeleteBuffers(1, &co->index_id);
if (co->vertex_id)
- glDeleteBuffers(1,&co->vertex_id);
+ glDeleteBuffers(1, &co->vertex_id);
canvas_occluder_owner.free(p_rid);
memdelete(co);
@@ -6437,9 +6055,9 @@ bool RasterizerStorageGLES3::free(RID p_rid){
} else if (canvas_light_shadow_owner.owns(p_rid)) {
CanvasLightShadow *cls = canvas_light_shadow_owner.get(p_rid);
- glDeleteFramebuffers(1,&cls->fbo);
- glDeleteRenderbuffers(1,&cls->depth);
- glDeleteTextures(1,&cls->distance);
+ glDeleteFramebuffers(1, &cls->fbo);
+ glDeleteRenderbuffers(1, &cls->depth);
+ glDeleteTextures(1, &cls->distance);
canvas_light_shadow_owner.free(p_rid);
memdelete(cls);
} else {
@@ -6449,206 +6067,193 @@ bool RasterizerStorageGLES3::free(RID p_rid){
return true;
}
+bool RasterizerStorageGLES3::has_os_feature(const String &p_feature) const {
-bool RasterizerStorageGLES3::has_os_feature(const String& p_feature) const {
-
- if (p_feature=="s3tc")
+ if (p_feature == "s3tc")
return config.s3tc_supported;
- if (p_feature=="etc")
+ if (p_feature == "etc")
return config.etc_supported;
- if (p_feature=="etc2")
+ if (p_feature == "etc2")
return config.etc2_supported;
- if (p_feature=="pvrtc")
+ if (p_feature == "pvrtc")
return config.pvrtc_supported;
return false;
-
}
////////////////////////////////////////////
-
void RasterizerStorageGLES3::initialize() {
- config.render_arch=RENDER_ARCH_DESKTOP;
+ config.render_arch = RENDER_ARCH_DESKTOP;
//config.fbo_deferred=int(Globals::get_singleton()->get("rendering/gles3/lighting_technique"));
- RasterizerStorageGLES3::system_fbo=0;
-
+ RasterizerStorageGLES3::system_fbo = 0;
//// extensions config
///
{
- int max_extensions=0;
+ int max_extensions = 0;
print_line("getting extensions");
- glGetIntegerv(GL_NUM_EXTENSIONS,&max_extensions);
- print_line("total "+itos(max_extensions));
- for(int i=0;i<max_extensions;i++) {
- const GLubyte *s = glGetStringi( GL_EXTENSIONS,i );
+ glGetIntegerv(GL_NUM_EXTENSIONS, &max_extensions);
+ print_line("total " + itos(max_extensions));
+ for (int i = 0; i < max_extensions; i++) {
+ const GLubyte *s = glGetStringi(GL_EXTENSIONS, i);
if (!s)
break;
- config.extensions.insert((const char*)s);
+ config.extensions.insert((const char *)s);
}
}
- config.shrink_textures_x2=false;
- config.use_fast_texture_filter=int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter"));
+ config.shrink_textures_x2 = false;
+ config.use_fast_texture_filter = int(GlobalConfig::get_singleton()->get("rendering/quality/use_nearest_mipmap_filter"));
config.use_anisotropic_filter = config.extensions.has("GL_EXT_texture_filter_anisotropic");
- config.s3tc_supported=config.extensions.has("GL_EXT_texture_compression_dxt1") || config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc");
- config.etc_supported=config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");
- config.latc_supported=config.extensions.has("GL_EXT_texture_compression_latc");
- config.bptc_supported=config.extensions.has("GL_ARB_texture_compression_bptc");
+ config.s3tc_supported = config.extensions.has("GL_EXT_texture_compression_dxt1") || config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc");
+ config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");
+ config.latc_supported = config.extensions.has("GL_EXT_texture_compression_latc");
+ config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc");
#ifdef GLES_OVER_GL
- config.hdr_supported=true;
- config.etc2_supported=false;
+ config.hdr_supported = true;
+ config.etc2_supported = false;
#else
- config.etc2_supported=true;
- config.hdr_supported=false;
+ config.etc2_supported = true;
+ config.hdr_supported = false;
#endif
- config.pvrtc_supported=config.extensions.has("GL_IMG_texture_compression_pvrtc");
- config.srgb_decode_supported=config.extensions.has("GL_EXT_texture_sRGB_decode");
-
+ config.pvrtc_supported = config.extensions.has("GL_IMG_texture_compression_pvrtc");
+ config.srgb_decode_supported = config.extensions.has("GL_EXT_texture_sRGB_decode");
-
- config.anisotropic_level=1.0;
- config.use_anisotropic_filter=config.extensions.has("GL_EXT_texture_filter_anisotropic");
+ config.anisotropic_level = 1.0;
+ config.use_anisotropic_filter = config.extensions.has("GL_EXT_texture_filter_anisotropic");
if (config.use_anisotropic_filter) {
- glGetFloatv(_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&config.anisotropic_level);
- config.anisotropic_level=MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")),config.anisotropic_level);
+ glGetFloatv(_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &config.anisotropic_level);
+ config.anisotropic_level = MIN(int(GlobalConfig::get_singleton()->get("rendering/quality/anisotropic_filter_level")), config.anisotropic_level);
}
-
- frame.clear_request=false;
+ frame.clear_request = false;
shaders.copy.init();
{
//default textures
-
glGenTextures(1, &resources.white_tex);
- unsigned char whitetexdata[8*8*3];
- for(int i=0;i<8*8*3;i++) {
- whitetexdata[i]=255;
+ unsigned char whitetexdata[8 * 8 * 3];
+ for (int i = 0; i < 8 * 8 * 3; i++) {
+ whitetexdata[i] = 255;
}
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,resources.white_tex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,whitetexdata);
+ glBindTexture(GL_TEXTURE_2D, resources.white_tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, whitetexdata);
glGenerateMipmap(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D,0);
+ glBindTexture(GL_TEXTURE_2D, 0);
glGenTextures(1, &resources.black_tex);
- unsigned char blacktexdata[8*8*3];
- for(int i=0;i<8*8*3;i++) {
- blacktexdata[i]=0;
+ unsigned char blacktexdata[8 * 8 * 3];
+ for (int i = 0; i < 8 * 8 * 3; i++) {
+ blacktexdata[i] = 0;
}
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,resources.black_tex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,blacktexdata);
+ glBindTexture(GL_TEXTURE_2D, resources.black_tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, blacktexdata);
glGenerateMipmap(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D,0);
+ glBindTexture(GL_TEXTURE_2D, 0);
glGenTextures(1, &resources.normal_tex);
- unsigned char normaltexdata[8*8*3];
- for(int i=0;i<8*8*3;i+=3) {
- normaltexdata[i+0]=128;
- normaltexdata[i+1]=128;
- normaltexdata[i+2]=255;
+ unsigned char normaltexdata[8 * 8 * 3];
+ for (int i = 0; i < 8 * 8 * 3; i += 3) {
+ normaltexdata[i + 0] = 128;
+ normaltexdata[i + 1] = 128;
+ normaltexdata[i + 2] = 255;
}
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,resources.normal_tex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,normaltexdata);
+ glBindTexture(GL_TEXTURE_2D, resources.normal_tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, normaltexdata);
glGenerateMipmap(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D,0);
-
+ glBindTexture(GL_TEXTURE_2D, 0);
glGenTextures(1, &resources.aniso_tex);
- unsigned char anisotexdata[8*8*3];
- for(int i=0;i<8*8*3;i+=3) {
- anisotexdata[i+0]=255;
- anisotexdata[i+1]=128;
- anisotexdata[i+2]=0;
+ unsigned char anisotexdata[8 * 8 * 3];
+ for (int i = 0; i < 8 * 8 * 3; i += 3) {
+ anisotexdata[i + 0] = 255;
+ anisotexdata[i + 1] = 128;
+ anisotexdata[i + 2] = 0;
}
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D,resources.aniso_tex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE,anisotexdata);
+ glBindTexture(GL_TEXTURE_2D, resources.aniso_tex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, anisotexdata);
glGenerateMipmap(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D,0);
-
+ glBindTexture(GL_TEXTURE_2D, 0);
}
- glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&config.max_texture_image_units);
- glGetIntegerv(GL_MAX_TEXTURE_SIZE,&config.max_texture_size);
+ glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &config.max_texture_image_units);
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, &config.max_texture_size);
#ifdef GLES_OVER_GL
- config.use_rgba_2d_shadows=false;
+ config.use_rgba_2d_shadows = false;
#else
- config.use_rgba_2d_shadows=true;
+ config.use_rgba_2d_shadows = true;
#endif
-
//generic quadie for copying
{
//quad buffers
- glGenBuffers(1,&resources.quadie);
- glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
+ glGenBuffers(1, &resources.quadie);
+ glBindBuffer(GL_ARRAY_BUFFER, resources.quadie);
{
- const float qv[16]={
- -1,-1,
- 0, 0,
+ const float qv[16] = {
+ -1, -1,
+ 0, 0,
-1, 1,
- 0, 1,
- 1, 1,
- 1, 1,
- 1,-1,
- 1, 0,
+ 0, 1,
+ 1, 1,
+ 1, 1,
+ 1, -1,
+ 1, 0,
};
- glBufferData(GL_ARRAY_BUFFER,sizeof(float)*16,qv,GL_STATIC_DRAW);
+ glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 16, qv, GL_STATIC_DRAW);
}
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
-
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
- glGenVertexArrays(1,&resources.quadie_array);
+ glGenVertexArrays(1, &resources.quadie_array);
glBindVertexArray(resources.quadie_array);
- glBindBuffer(GL_ARRAY_BUFFER,resources.quadie);
- glVertexAttribPointer(VS::ARRAY_VERTEX,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,0);
+ glBindBuffer(GL_ARRAY_BUFFER, resources.quadie);
+ glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0);
glEnableVertexAttribArray(0);
- glVertexAttribPointer(VS::ARRAY_TEX_UV,2,GL_FLOAT,GL_FALSE,sizeof(float)*4,((uint8_t*)NULL)+8);
+ glVertexAttribPointer(VS::ARRAY_TEX_UV, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, ((uint8_t *)NULL) + 8);
glEnableVertexAttribArray(4);
glBindVertexArray(0);
- glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+ glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
}
//generic quadie for copying without touching skybox
{
//transform feedback buffers
- uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb",4096);
- for(int i=0;i<2;i++) {
+ uint32_t xf_feedback_size = GLOBAL_DEF("rendering/buffers/blend_shape_max_buffer_size_kb", 4096);
+ for (int i = 0; i < 2; i++) {
- glGenBuffers(1,&resources.transform_feedback_buffers[i]);
- glBindBuffer(GL_ARRAY_BUFFER,resources.transform_feedback_buffers[i]);
- glBufferData(GL_ARRAY_BUFFER,xf_feedback_size*1024,NULL,GL_STREAM_DRAW);
+ glGenBuffers(1, &resources.transform_feedback_buffers[i]);
+ glBindBuffer(GL_ARRAY_BUFFER, resources.transform_feedback_buffers[i]);
+ glBufferData(GL_ARRAY_BUFFER, xf_feedback_size * 1024, NULL, GL_STREAM_DRAW);
}
shaders.blend_shapes.init();
- glGenVertexArrays(1,&resources.transform_feedback_array);
-
+ glGenVertexArrays(1, &resources.transform_feedback_array);
}
shaders.cubemap_filter.init();
@@ -6656,10 +6261,10 @@ void RasterizerStorageGLES3::initialize() {
glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
- frame.count=0;
- frame.prev_tick=0;
- frame.delta=0;
- config.keep_original_textures=false;
+ frame.count = 0;
+ frame.prev_tick = 0;
+ frame.delta = 0;
+ config.keep_original_textures = false;
}
void RasterizerStorageGLES3::finalize() {
@@ -6667,7 +6272,6 @@ void RasterizerStorageGLES3::finalize() {
glDeleteTextures(1, &resources.white_tex);
glDeleteTextures(1, &resources.black_tex);
glDeleteTextures(1, &resources.normal_tex);
-
}
void RasterizerStorageGLES3::update_dirty_resources() {
@@ -6679,7 +6283,5 @@ void RasterizerStorageGLES3::update_dirty_resources() {
update_particles();
}
-RasterizerStorageGLES3::RasterizerStorageGLES3()
-{
-
+RasterizerStorageGLES3::RasterizerStorageGLES3() {
}
diff --git a/drivers/gles3/rasterizer_storage_gles3.h b/drivers/gles3/rasterizer_storage_gles3.h
index 1fa15538d..343cee213 100644
--- a/drivers/gles3/rasterizer_storage_gles3.h
+++ b/drivers/gles3/rasterizer_storage_gles3.h
@@ -29,27 +29,26 @@
#ifndef RASTERIZERSTORAGEGLES3_H
#define RASTERIZERSTORAGEGLES3_H
+#include "self_list.h"
#include "servers/visual/rasterizer.h"
#include "servers/visual/shader_language.h"
+#include "shader_compiler_gles3.h"
#include "shader_gles3.h"
-#include "shaders/copy.glsl.h"
-#include "shaders/canvas.glsl.h"
#include "shaders/blend_shape.glsl.h"
+#include "shaders/canvas.glsl.h"
+#include "shaders/copy.glsl.h"
#include "shaders/cubemap_filter.glsl.h"
#include "shaders/particles.glsl.h"
-#include "self_list.h"
-#include "shader_compiler_gles3.h"
class RasterizerCanvasGLES3;
class RasterizerSceneGLES3;
-#define _TEXTURE_SRGB_DECODE_EXT 0x8A48
-#define _DECODE_EXT 0x8A49
-#define _SKIP_DECODE_EXT 0x8A4A
+#define _TEXTURE_SRGB_DECODE_EXT 0x8A48
+#define _DECODE_EXT 0x8A49
+#define _SKIP_DECODE_EXT 0x8A4A
class RasterizerStorageGLES3 : public RasterizerStorage {
public:
-
RasterizerCanvasGLES3 *canvas;
RasterizerSceneGLES3 *scene;
static GLuint system_fbo; //on some devices, such as apple, screen is rendered to yet another fbo.
@@ -134,18 +133,9 @@ public:
} info;
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////DATA///////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////
-
-
-
-
-
-
-
-
+ /////////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////DATA///////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////////////////////////////////////
struct Instantiable : public RID_Data {
@@ -154,37 +144,35 @@ public:
_FORCE_INLINE_ void instance_change_notify() {
SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
- while(instances) {
+ while (instances) {
instances->self()->base_changed();
- instances=instances->next();
+ instances = instances->next();
}
}
_FORCE_INLINE_ void instance_material_change_notify() {
SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
- while(instances) {
+ while (instances) {
instances->self()->base_material_changed();
- instances=instances->next();
+ instances = instances->next();
}
}
_FORCE_INLINE_ void instance_remove_deps() {
SelfList<RasterizerScene::InstanceBase> *instances = instance_list.first();
- while(instances) {
+ while (instances) {
SelfList<RasterizerScene::InstanceBase> *next = instances->next();
instances->self()->base_removed();
- instances=next;
+ instances = next;
}
}
-
- Instantiable() { }
+ Instantiable() {}
virtual ~Instantiable() {
-
}
};
@@ -201,7 +189,6 @@ public:
GEOMETRY_MULTISURFACE,
};
-
Type type;
RID material;
uint64_t last_pass;
@@ -210,18 +197,14 @@ public:
virtual void material_changed_notify() {}
Geometry() {
- last_pass=0;
- index=0;
+ last_pass = 0;
+ index = 0;
}
-
};
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////API////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////
-
+ /////////////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////API////////////////////////////////////////////////////
+ /////////////////////////////////////////////////////////////////////////////////////////
/* TEXTURE API */
@@ -231,7 +214,7 @@ public:
String path;
uint32_t flags;
- int width,height;
+ int width, height;
int alloc_width, alloc_height;
Image::Format format;
@@ -266,64 +249,62 @@ public:
Texture() {
- using_srgb=false;
- stored_cube_sides=0;
- ignore_mipmaps=false;
- render_target=NULL;
- flags=width=height=0;
- tex_id=0;
- data_size=0;
- format=Image::FORMAT_L8;
- active=false;
- compressed=false;
- total_data_size=0;
- target=GL_TEXTURE_2D;
- mipmaps=0;
- detect_3d=NULL;
- detect_3d_ud=NULL;
- detect_srgb=NULL;
- detect_srgb_ud=NULL;
-
+ using_srgb = false;
+ stored_cube_sides = 0;
+ ignore_mipmaps = false;
+ render_target = NULL;
+ flags = width = height = 0;
+ tex_id = 0;
+ data_size = 0;
+ format = Image::FORMAT_L8;
+ active = false;
+ compressed = false;
+ total_data_size = 0;
+ target = GL_TEXTURE_2D;
+ mipmaps = 0;
+ detect_3d = NULL;
+ detect_3d_ud = NULL;
+ detect_srgb = NULL;
+ detect_srgb_ud = NULL;
}
~Texture() {
- if (tex_id!=0) {
+ if (tex_id != 0) {
- glDeleteTextures(1,&tex_id);
+ glDeleteTextures(1, &tex_id);
}
}
};
mutable RID_Owner<Texture> texture_owner;
- Image _get_gl_image_and_format(const Image& p_image, Image::Format p_format, uint32_t p_flags, GLenum& r_gl_format, GLenum& r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
+ Image _get_gl_image_and_format(const Image &p_image, Image::Format p_format, uint32_t p_flags, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_type, bool &r_compressed, bool &srgb);
virtual RID texture_create();
- virtual void texture_allocate(RID p_texture,int p_width, int p_height,Image::Format p_format,uint32_t p_flags=VS::TEXTURE_FLAGS_DEFAULT);
- virtual void texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT);
- virtual Image texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side=VS::CUBEMAP_LEFT) const;
- virtual void texture_set_flags(RID p_texture,uint32_t p_flags);
+ virtual void texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags = VS::TEXTURE_FLAGS_DEFAULT);
+ virtual void texture_set_data(RID p_texture, const Image &p_image, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT);
+ virtual Image texture_get_data(RID p_texture, VS::CubeMapSide p_cube_side = VS::CUBEMAP_LEFT) const;
+ virtual void texture_set_flags(RID p_texture, uint32_t p_flags);
virtual uint32_t texture_get_flags(RID p_texture) const;
virtual Image::Format texture_get_format(RID p_texture) const;
virtual uint32_t texture_get_width(RID p_texture) const;
virtual uint32_t texture_get_height(RID p_texture) const;
- virtual void texture_set_size_override(RID p_texture,int p_width, int p_height);
+ virtual void texture_set_size_override(RID p_texture, int p_width, int p_height);
- virtual void texture_set_path(RID p_texture,const String& p_path);
+ virtual void texture_set_path(RID p_texture, const String &p_path);
virtual String texture_get_path(RID p_texture) const;
virtual void texture_set_shrink_all_x2_on_set_data(bool p_enable);
virtual void texture_debug_usage(List<VS::TextureInfo> *r_info);
- virtual RID texture_create_radiance_cubemap(RID p_source,int p_resolution=-1) const;
+ virtual RID texture_create_radiance_cubemap(RID p_source, int p_resolution = -1) const;
virtual void textures_keep_original(bool p_enable);
- virtual void texture_set_detect_3d_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata);
- virtual void texture_set_detect_srgb_callback(RID p_texture,VisualServer::TextureDetectCallback p_callback,void* p_userdata);
-
+ virtual void texture_set_detect_3d_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata);
+ virtual void texture_set_detect_srgb_callback(RID p_texture, VisualServer::TextureDetectCallback p_callback, void *p_userdata);
/* SKYBOX API */
@@ -337,7 +318,7 @@ public:
mutable RID_Owner<SkyBox> skybox_owner;
virtual RID skybox_create();
- virtual void skybox_set_texture(RID p_skybox,RID p_cube_map,int p_radiance_size);
+ virtual void skybox_set_texture(RID p_skybox, RID p_cube_map, int p_radiance_size);
/* SHADER API */
@@ -352,9 +333,7 @@ public:
String code;
SelfList<Material>::List materials;
-
-
- Map<StringName,ShaderLanguage::ShaderNode::Uniform> uniforms;
+ Map<StringName, ShaderLanguage::ShaderNode::Uniform> uniforms;
Vector<uint32_t> ubo_offsets;
uint32_t ubo_size;
@@ -365,7 +344,7 @@ public:
SelfList<Shader> dirty_list;
- Map<StringName,RID> default_textures;
+ Map<StringName, RID> default_textures;
Vector<ShaderLanguage::ShaderNode::Uniform::Hint> texture_hints;
@@ -434,45 +413,42 @@ public:
struct Particles {
-
} particles;
-
bool uses_vertex_time;
bool uses_fragment_time;
- Shader() : dirty_list(this) {
+ Shader()
+ : dirty_list(this) {
- shader=NULL;
- valid=false;
- custom_code_id=0;
- version=1;
+ shader = NULL;
+ valid = false;
+ custom_code_id = 0;
+ version = 1;
}
};
mutable SelfList<Shader>::List _shader_dirty_list;
- void _shader_make_dirty(Shader* p_shader);
+ void _shader_make_dirty(Shader *p_shader);
mutable RID_Owner<Shader> shader_owner;
- virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_SPATIAL);
+ virtual RID shader_create(VS::ShaderMode p_mode = VS::SHADER_SPATIAL);
- virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode);
+ virtual void shader_set_mode(RID p_shader, VS::ShaderMode p_mode);
virtual VS::ShaderMode shader_get_mode(RID p_shader) const;
- virtual void shader_set_code(RID p_shader, const String& p_code);
+ virtual void shader_set_code(RID p_shader, const String &p_code);
virtual String shader_get_code(RID p_shader) const;
virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
- virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
- virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
+ virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture);
+ virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const;
- void _update_shader(Shader* p_shader) const;
+ void _update_shader(Shader *p_shader) const;
void update_dirty_shaders();
-
-
/* COMMON MATERIAL API */
struct Material : public RID_Data {
@@ -480,7 +456,7 @@ public:
Shader *shader;
GLuint ubo_id;
uint32_t ubo_size;
- Map<StringName,Variant> params;
+ Map<StringName, Variant> params;
SelfList<Material> list;
SelfList<Material> dirty_list;
Vector<RID> textures;
@@ -489,30 +465,29 @@ public:
uint32_t index;
uint64_t last_pass;
- Map<Geometry*,int> geometry_owners;
- Map<RasterizerScene::InstanceBase*,int> instance_owners;
+ Map<Geometry *, int> geometry_owners;
+ Map<RasterizerScene::InstanceBase *, int> instance_owners;
bool can_cast_shadow_cache;
bool is_animated_cache;
- Material() : list(this), dirty_list(this) {
- can_cast_shadow_cache=false;
- is_animated_cache=false;
- shader=NULL;
- line_width=1.0;
- ubo_id=0;
- ubo_size=0;
- last_pass=0;
+ Material()
+ : list(this), dirty_list(this) {
+ can_cast_shadow_cache = false;
+ is_animated_cache = false;
+ shader = NULL;
+ line_width = 1.0;
+ ubo_id = 0;
+ ubo_size = 0;
+ last_pass = 0;
}
-
};
mutable SelfList<Material>::List _material_dirty_list;
void _material_make_dirty(Material *p_material) const;
- void _material_add_geometry(RID p_material,Geometry *p_instantiable);
+ void _material_add_geometry(RID p_material, Geometry *p_instantiable);
void _material_remove_geometry(RID p_material, Geometry *p_instantiable);
-
mutable RID_Owner<Material> material_owner;
virtual RID material_create();
@@ -520,8 +495,8 @@ public:
virtual void material_set_shader(RID p_material, RID p_shader);
virtual RID material_get_shader(RID p_material) const;
- virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value);
- virtual Variant material_get_param(RID p_material, const StringName& p_param) const;
+ virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value);
+ virtual Variant material_get_param(RID p_material, const StringName &p_param) const;
virtual void material_set_line_width(RID p_material, float p_width);
@@ -531,17 +506,12 @@ public:
virtual void material_add_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance);
virtual void material_remove_instance_owner(RID p_material, RasterizerScene::InstanceBase *p_instance);
- void _update_material(Material* material);
+ void _update_material(Material *material);
void update_dirty_materials();
/* MESH API */
-
-
-
-
-
struct Mesh;
struct Surface : public Geometry {
@@ -559,8 +529,6 @@ public:
Attrib attribs[VS::ARRAY_MAX];
-
-
Mesh *mesh;
uint32_t format;
@@ -590,7 +558,6 @@ public:
int array_byte_size;
int index_array_byte_size;
-
VS::PrimitiveType primitive;
bool active;
@@ -602,23 +569,21 @@ public:
Surface() {
- array_byte_size=0;
- index_array_byte_size=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;
-
+ array_byte_size = 0;
+ index_array_byte_size = 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() {
-
}
};
@@ -627,7 +592,7 @@ public:
struct Mesh : public GeometryOwner {
bool active;
- Vector<Surface*> surfaces;
+ Vector<Surface *> surfaces;
int blend_shape_count;
VS::BlendShapeMode blend_shape_mode;
Rect3 custom_aabb;
@@ -637,17 +602,17 @@ public:
_FORCE_INLINE_ void update_multimeshes() {
SelfList<MultiMesh> *mm = multimeshes.first();
- while(mm) {
+ while (mm) {
mm->self()->instance_material_change_notify();
- mm=mm->next();
+ mm = mm->next();
}
}
Mesh() {
- blend_shape_mode=VS::BLEND_SHAPE_MODE_NORMALIZED;
- blend_shape_count=0;
- last_pass=0;
- active=false;
+ blend_shape_mode = VS::BLEND_SHAPE_MODE_NORMALIZED;
+ blend_shape_count = 0;
+ last_pass = 0;
+ active = false;
}
};
@@ -655,13 +620,12 @@ public:
virtual RID mesh_create();
- virtual void mesh_add_surface(RID p_mesh,uint32_t p_format,VS::PrimitiveType p_primitive,const PoolVector<uint8_t>& p_array,int p_vertex_count,const PoolVector<uint8_t>& p_index_array,int p_index_count,const Rect3& p_aabb,const Vector<PoolVector<uint8_t> >& p_blend_shapes=Vector<PoolVector<uint8_t> >(),const Vector<Rect3>& p_bone_aabbs=Vector<Rect3>());
+ virtual void mesh_add_surface(RID p_mesh, uint32_t p_format, VS::PrimitiveType p_primitive, const PoolVector<uint8_t> &p_array, int p_vertex_count, const PoolVector<uint8_t> &p_index_array, int p_index_count, const Rect3 &p_aabb, const Vector<PoolVector<uint8_t> > &p_blend_shapes = Vector<PoolVector<uint8_t> >(), const Vector<Rect3> &p_bone_aabbs = Vector<Rect3>());
- virtual void mesh_set_blend_shape_count(RID p_mesh,int p_amount);
+ virtual void mesh_set_blend_shape_count(RID p_mesh, int p_amount);
virtual int mesh_get_blend_shape_count(RID p_mesh) const;
-
- virtual void mesh_set_blend_shape_mode(RID p_mesh,VS::BlendShapeMode p_mode);
+ virtual void mesh_set_blend_shape_mode(RID p_mesh, VS::BlendShapeMode p_mode);
virtual VS::BlendShapeMode mesh_get_blend_shape_mode(RID p_mesh) const;
virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material);
@@ -673,7 +637,6 @@ public:
virtual PoolVector<uint8_t> mesh_surface_get_array(RID p_mesh, int p_surface) const;
virtual PoolVector<uint8_t> mesh_surface_get_index_array(RID p_mesh, int p_surface) const;
-
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;
@@ -684,7 +647,7 @@ public:
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 Rect3& p_aabb);
+ virtual void mesh_set_custom_aabb(RID p_mesh, const Rect3 &p_aabb);
virtual Rect3 mesh_get_custom_aabb(RID p_mesh) const;
virtual Rect3 mesh_get_aabb(RID p_mesh, RID p_skeleton) const;
@@ -712,16 +675,17 @@ public:
bool dirty_aabb;
bool dirty_data;
- MultiMesh() : update_list(this), mesh_list(this) {
- dirty_aabb=true;
- dirty_data=true;
- xform_floats=0;
- color_floats=0;
- visible_instances=-1;
- size=0;
- buffer=0;
- transform_format=VS::MULTIMESH_TRANSFORM_2D;
- color_format=VS::MULTIMESH_COLOR_NONE;
+ MultiMesh()
+ : update_list(this), mesh_list(this) {
+ dirty_aabb = true;
+ dirty_data = true;
+ xform_floats = 0;
+ color_floats = 0;
+ visible_instances = -1;
+ size = 0;
+ buffer = 0;
+ transform_format = VS::MULTIMESH_TRANSFORM_2D;
+ color_format = VS::MULTIMESH_COLOR_NONE;
}
};
@@ -733,21 +697,21 @@ public:
virtual RID multimesh_create();
- virtual void multimesh_allocate(RID p_multimesh,int p_instances,VS::MultimeshTransformFormat p_transform_format,VS::MultimeshColorFormat p_color_format);
+ virtual void multimesh_allocate(RID p_multimesh, int p_instances, VS::MultimeshTransformFormat p_transform_format, VS::MultimeshColorFormat p_color_format);
virtual int multimesh_get_instance_count(RID p_multimesh) const;
- virtual void multimesh_set_mesh(RID p_multimesh,RID p_mesh);
- virtual void multimesh_instance_set_transform(RID p_multimesh,int p_index,const Transform& p_transform);
- virtual void multimesh_instance_set_transform_2d(RID p_multimesh,int p_index,const Transform2D& p_transform);
- virtual void multimesh_instance_set_color(RID p_multimesh,int p_index,const Color& p_color);
+ virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh);
+ virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform);
+ virtual void multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform);
+ virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color);
virtual RID multimesh_get_mesh(RID p_multimesh) const;
- virtual Transform multimesh_instance_get_transform(RID p_multimesh,int p_index) const;
- virtual Transform2D multimesh_instance_get_transform_2d(RID p_multimesh,int p_index) const;
- virtual Color multimesh_instance_get_color(RID p_multimesh,int p_index) const;
+ virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const;
+ virtual Transform2D multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const;
+ virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const;
- virtual void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+ virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible);
virtual int multimesh_get_visible_instances(RID p_multimesh) const;
virtual Rect3 multimesh_get_aabb(RID p_multimesh) const;
@@ -773,8 +737,10 @@ public:
int mask;
Rect3 aabb;
- Immediate() { type=GEOMETRY_IMMEDIATE; building=false;}
-
+ Immediate() {
+ type = GEOMETRY_IMMEDIATE;
+ building = false;
+ }
};
Vector3 chunk_vertex;
@@ -787,16 +753,16 @@ public:
mutable RID_Owner<Immediate> immediate_owner;
virtual RID immediate_create();
- virtual void immediate_begin(RID p_immediate,VS::PrimitiveType p_rimitive,RID p_texture=RID());
- virtual void immediate_vertex(RID p_immediate,const Vector3& p_vertex);
- virtual void immediate_normal(RID p_immediate,const Vector3& p_normal);
- virtual void immediate_tangent(RID p_immediate,const Plane& p_tangent);
- virtual void immediate_color(RID p_immediate,const Color& p_color);
- virtual void immediate_uv(RID p_immediate,const Vector2& tex_uv);
- virtual void immediate_uv2(RID p_immediate,const Vector2& tex_uv);
+ virtual void immediate_begin(RID p_immediate, VS::PrimitiveType p_rimitive, RID p_texture = RID());
+ virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex);
+ virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal);
+ virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent);
+ virtual void immediate_color(RID p_immediate, const Color &p_color);
+ virtual void immediate_uv(RID p_immediate, const Vector2 &tex_uv);
+ virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv);
virtual void immediate_end(RID p_immediate);
virtual void immediate_clear(RID p_immediate);
- virtual void immediate_set_material(RID p_immediate,RID p_material);
+ virtual void immediate_set_material(RID p_immediate, RID p_material);
virtual RID immediate_get_material(RID p_immediate) const;
virtual Rect3 immediate_get_aabb(RID p_immediate) const;
@@ -808,12 +774,13 @@ public:
Vector<float> bones; //4x3 or 4x2 depending on what is needed
GLuint ubo;
SelfList<Skeleton> update_list;
- Set<RasterizerScene::InstanceBase*> instances; //instances using skeleton
+ Set<RasterizerScene::InstanceBase *> instances; //instances using skeleton
- Skeleton() : update_list(this) {
- size=0;
- use_2d=false;
- ubo=0;
+ Skeleton()
+ : update_list(this) {
+ size = 0;
+ use_2d = false;
+ ubo = 0;
}
};
@@ -824,16 +791,15 @@ public:
void update_dirty_skeletons();
virtual RID skeleton_create();
- virtual void skeleton_allocate(RID p_skeleton,int p_bones,bool p_2d_skeleton=false);
+ virtual void skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton = false);
virtual int skeleton_get_bone_count(RID p_skeleton) const;
- virtual void skeleton_bone_set_transform(RID p_skeleton,int p_bone, const Transform& p_transform);
- virtual Transform skeleton_bone_get_transform(RID p_skeleton,int p_bone) const;
- virtual void skeleton_bone_set_transform_2d(RID p_skeleton,int p_bone, const Transform2D& p_transform);
- virtual Transform2D skeleton_bone_get_transform_2d(RID p_skeleton,int p_bone) const;
+ virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform);
+ virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone) const;
+ virtual void skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform);
+ virtual Transform2D skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const;
/* Light API */
-
struct Light : Instantiable {
VS::LightType type;
@@ -855,20 +821,19 @@ public:
virtual RID light_create(VS::LightType p_type);
- virtual void light_set_color(RID p_light,const Color& p_color);
- virtual void light_set_param(RID p_light,VS::LightParam p_param,float p_value);
- virtual void light_set_shadow(RID p_light,bool p_enabled);
- virtual void light_set_shadow_color(RID p_light,const Color& p_color);
- virtual void light_set_projector(RID p_light,RID p_texture);
- virtual void light_set_negative(RID p_light,bool p_enable);
- virtual void light_set_cull_mask(RID p_light,uint32_t p_mask);
+ virtual void light_set_color(RID p_light, const Color &p_color);
+ virtual void light_set_param(RID p_light, VS::LightParam p_param, float p_value);
+ virtual void light_set_shadow(RID p_light, bool p_enabled);
+ virtual void light_set_shadow_color(RID p_light, const Color &p_color);
+ virtual void light_set_projector(RID p_light, RID p_texture);
+ virtual void light_set_negative(RID p_light, bool p_enable);
+ virtual void light_set_cull_mask(RID p_light, uint32_t p_mask);
+ virtual void light_omni_set_shadow_mode(RID p_light, VS::LightOmniShadowMode p_mode);
+ virtual void light_omni_set_shadow_detail(RID p_light, VS::LightOmniShadowDetail p_detail);
- virtual void light_omni_set_shadow_mode(RID p_light,VS::LightOmniShadowMode p_mode);
- virtual void light_omni_set_shadow_detail(RID p_light,VS::LightOmniShadowDetail p_detail);
-
- virtual void light_directional_set_shadow_mode(RID p_light,VS::LightDirectionalShadowMode p_mode);
- virtual void light_directional_set_blend_splits(RID p_light,bool p_enable);
+ virtual void light_directional_set_shadow_mode(RID p_light, VS::LightDirectionalShadowMode p_mode);
+ virtual void light_directional_set_blend_splits(RID p_light, bool p_enable);
virtual bool light_directional_get_blend_splits(RID p_light) const;
virtual VS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light);
@@ -877,7 +842,7 @@ public:
virtual bool light_has_shadow(RID p_light) const;
virtual VS::LightType light_get_type(RID p_light) const;
- virtual float light_get_param(RID p_light,VS::LightParam p_param);
+ virtual float light_get_param(RID p_light, VS::LightParam p_param);
virtual Color light_get_color(RID p_light);
virtual Rect3 light_get_aabb(RID p_light) const;
@@ -899,7 +864,6 @@ public:
bool box_projection;
bool enable_shadows;
uint32_t cull_mask;
-
};
mutable RID_Owner<ReflectionProbe> reflection_probe_owner;
@@ -908,12 +872,12 @@ public:
virtual void reflection_probe_set_update_mode(RID p_probe, VS::ReflectionProbeUpdateMode p_mode);
virtual void reflection_probe_set_intensity(RID p_probe, float p_intensity);
- virtual void reflection_probe_set_interior_ambient(RID p_probe, const Color& p_ambient);
+ virtual void reflection_probe_set_interior_ambient(RID p_probe, const Color &p_ambient);
virtual void reflection_probe_set_interior_ambient_energy(RID p_probe, float p_energy);
virtual void reflection_probe_set_interior_ambient_probe_contribution(RID p_probe, float p_contrib);
virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance);
- virtual void reflection_probe_set_extents(RID p_probe, const Vector3& p_extents);
- virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3& p_offset);
+ virtual void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents);
+ virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset);
virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable);
virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable);
virtual void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable);
@@ -928,13 +892,10 @@ public:
virtual float reflection_probe_get_origin_max_distance(RID p_probe) const;
virtual bool reflection_probe_renders_shadows(RID p_probe) const;
-
-
-
/* ROOM API */
virtual RID room_create();
- virtual void room_add_bounds(RID p_room, const PoolVector<Vector2>& p_convex_polygon,float p_height,const Transform& p_transform);
+ virtual void room_add_bounds(RID p_room, const PoolVector<Vector2> &p_convex_polygon, float p_height, const Transform &p_transform);
virtual void room_clear_bounds(RID p_room);
/* PORTAL API */
@@ -943,22 +904,15 @@ public:
// order points outside. (z is 0);
virtual RID portal_create();
- virtual void portal_set_shape(RID p_portal, const Vector<Point2>& p_shape);
+ virtual void portal_set_shape(RID p_portal, const Vector<Point2> &p_shape);
virtual void portal_set_enabled(RID p_portal, bool p_enabled);
virtual void portal_set_disable_distance(RID p_portal, float p_distance);
- virtual void portal_set_disabled_color(RID p_portal, const Color& p_color);
-
-
-
-
-
-
+ virtual void portal_set_disabled_color(RID p_portal, const Color &p_color);
/* GI PROBE API */
struct GIProbe : public Instantiable {
-
Rect3 bounds;
Transform to_cell;
float cell_size;
@@ -973,42 +927,40 @@ public:
uint32_t version;
PoolVector<int> dynamic_data;
-
-
};
mutable RID_Owner<GIProbe> gi_probe_owner;
virtual RID gi_probe_create();
- virtual void gi_probe_set_bounds(RID p_probe,const Rect3& p_bounds);
+ virtual void gi_probe_set_bounds(RID p_probe, const Rect3 &p_bounds);
virtual Rect3 gi_probe_get_bounds(RID p_probe) const;
virtual void gi_probe_set_cell_size(RID p_probe, float p_size);
virtual float gi_probe_get_cell_size(RID p_probe) const;
- virtual void gi_probe_set_to_cell_xform(RID p_probe,const Transform& p_xform);
+ virtual void gi_probe_set_to_cell_xform(RID p_probe, const Transform &p_xform);
virtual Transform gi_probe_get_to_cell_xform(RID p_probe) const;
- virtual void gi_probe_set_dynamic_data(RID p_probe,const PoolVector<int>& p_data);
+ virtual void gi_probe_set_dynamic_data(RID p_probe, const PoolVector<int> &p_data);
virtual PoolVector<int> gi_probe_get_dynamic_data(RID p_probe) const;
- virtual void gi_probe_set_dynamic_range(RID p_probe,int p_range);
+ 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 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_bias(RID p_probe,float p_range);
+ virtual void gi_probe_set_bias(RID p_probe, float p_range);
virtual float gi_probe_get_bias(RID p_probe) const;
- virtual void gi_probe_set_propagation(RID p_probe,float p_range);
+ virtual void gi_probe_set_propagation(RID p_probe, float p_range);
virtual float gi_probe_get_propagation(RID p_probe) const;
- virtual void gi_probe_set_interior(RID p_probe,bool p_enable);
+ 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_compress(RID p_probe,bool p_enable);
+ virtual void gi_probe_set_compress(RID p_probe, bool p_enable);
virtual bool gi_probe_is_compressed(RID p_probe) const;
virtual uint32_t gi_probe_get_version(RID p_probe);
@@ -1029,8 +981,8 @@ public:
mutable RID_Owner<GIProbeData> gi_probe_data_owner;
virtual GIProbeCompression gi_probe_get_dynamic_data_get_preferred_compression() const;
- virtual RID gi_probe_dynamic_data_create(int p_width,int p_height,int p_depth,GIProbeCompression p_compression);
- virtual void gi_probe_dynamic_data_update(RID p_gi_probe_data,int p_depth_slice,int p_slice_count,int p_mipmap,const void* p_data);
+ virtual RID gi_probe_dynamic_data_create(int p_width, int p_height, int p_depth, GIProbeCompression p_compression);
+ virtual void gi_probe_dynamic_data_update(RID p_gi_probe_data, int p_depth_slice, int p_slice_count, int p_mipmap, const void *p_data);
/* PARTICLES */
@@ -1073,77 +1025,74 @@ public:
Transform origin;
- Particles() : particle_element(this) {
- emitting=false;
- amount=0;
- lifetime=1.0;
- pre_process_time=0.0;
- explosiveness=0.0;
- randomness=0.0;
- use_local_coords=true;
+ Particles()
+ : particle_element(this) {
+ emitting = false;
+ amount = 0;
+ lifetime = 1.0;
+ pre_process_time = 0.0;
+ explosiveness = 0.0;
+ randomness = 0.0;
+ use_local_coords = true;
- draw_order=VS::PARTICLES_DRAW_ORDER_INDEX;
- emission_shape=VS::PARTICLES_EMSSION_POINT;
- emission_sphere_radius=1.0;
- emission_box_extents=Vector3(1,1,1);
- emission_point_texture=0;
- particle_buffers[0]=0;
- particle_buffers[1]=0;
+ draw_order = VS::PARTICLES_DRAW_ORDER_INDEX;
+ emission_shape = VS::PARTICLES_EMSSION_POINT;
+ emission_sphere_radius = 1.0;
+ emission_box_extents = Vector3(1, 1, 1);
+ emission_point_texture = 0;
+ particle_buffers[0] = 0;
+ particle_buffers[1] = 0;
- prev_ticks=0;
+ prev_ticks = 0;
- glGenBuffers(2,particle_buffers);
+ glGenBuffers(2, particle_buffers);
}
~Particles() {
- glDeleteBuffers(2,particle_buffers);
+ glDeleteBuffers(2, particle_buffers);
}
-
-
};
SelfList<Particles>::List particle_update_list;
void update_particles();
-
mutable RID_Owner<Particles> particles_owner;
virtual RID particles_create();
- virtual void particles_set_emitting(RID p_particles,bool p_emitting);
- virtual void particles_set_amount(RID p_particles,int p_amount);
- virtual void particles_set_lifetime(RID p_particles,float p_lifetime);
- virtual void particles_set_pre_process_time(RID p_particles,float p_time);
- virtual void particles_set_explosiveness_ratio(RID p_particles,float p_ratio);
- virtual void particles_set_randomness_ratio(RID p_particles,float p_ratio);
- virtual void particles_set_custom_aabb(RID p_particles,const Rect3& p_aabb);
- virtual void particles_set_gravity(RID p_particles,const Vector3& p_gravity);
- virtual void particles_set_use_local_coordinates(RID p_particles,bool p_enable);
- virtual void particles_set_process_material(RID p_particles,RID p_material);
+ virtual void particles_set_emitting(RID p_particles, bool p_emitting);
+ virtual void particles_set_amount(RID p_particles, int p_amount);
+ virtual void particles_set_lifetime(RID p_particles, float p_lifetime);
+ virtual void particles_set_pre_process_time(RID p_particles, float p_time);
+ virtual void particles_set_explosiveness_ratio(RID p_particles, float p_ratio);
+ virtual void particles_set_randomness_ratio(RID p_particles, float p_ratio);
+ virtual void particles_set_custom_aabb(RID p_particles, const Rect3 &p_aabb);
+ virtual void particles_set_gravity(RID p_particles, const Vector3 &p_gravity);
+ virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable);
+ virtual void particles_set_process_material(RID p_particles, RID p_material);
- virtual void particles_set_emission_shape(RID p_particles,VS::ParticlesEmissionShape p_shape);
- virtual void particles_set_emission_sphere_radius(RID p_particles,float p_radius);
- virtual void particles_set_emission_box_extents(RID p_particles,const Vector3& p_extents);
- virtual void particles_set_emission_points(RID p_particles,const PoolVector<Vector3>& p_points);
+ virtual void particles_set_emission_shape(RID p_particles, VS::ParticlesEmissionShape p_shape);
+ virtual void particles_set_emission_sphere_radius(RID p_particles, float p_radius);
+ virtual void particles_set_emission_box_extents(RID p_particles, const Vector3 &p_extents);
+ virtual void particles_set_emission_points(RID p_particles, const PoolVector<Vector3> &p_points);
+ virtual void particles_set_draw_order(RID p_particles, VS::ParticlesDrawOrder p_order);
- virtual void particles_set_draw_order(RID p_particles,VS::ParticlesDrawOrder p_order);
-
- virtual void particles_set_draw_passes(RID p_particles,int p_count);
- virtual void particles_set_draw_pass_material(RID p_particles,int p_pass, RID p_material);
- virtual void particles_set_draw_pass_mesh(RID p_particles,int p_pass, RID p_mesh);
+ virtual void particles_set_draw_passes(RID p_particles, int p_count);
+ virtual void particles_set_draw_pass_material(RID p_particles, int p_pass, RID p_material);
+ virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh);
virtual Rect3 particles_get_current_aabb(RID p_particles);
/* INSTANCE */
- virtual void instance_add_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance);
- virtual void instance_remove_skeleton(RID p_skeleton,RasterizerScene::InstanceBase *p_instance);
+ virtual void instance_add_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance);
+ virtual void instance_remove_skeleton(RID p_skeleton, RasterizerScene::InstanceBase *p_instance);
- virtual void instance_add_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
- virtual void instance_remove_dependency(RID p_base,RasterizerScene::InstanceBase *p_instance);
+ 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 */
@@ -1180,7 +1129,10 @@ public:
GLuint color;
int levels;
- MipMaps() { color=0; levels=0;}
+ MipMaps() {
+ color = 0;
+ levels = 0;
+ }
};
MipMaps mip_maps[2]; //first mipmap chain starts from full-screen
@@ -1194,7 +1146,11 @@ public:
Vector<GLuint> depth_mipmap_fbos; //fbos for depth mipmapsla ver
- SSAO() { blur_fbo[0]=0; blur_fbo[1]=0; linear_depth=0; }
+ SSAO() {
+ blur_fbo[0] = 0;
+ blur_fbo[1] = 0;
+ linear_depth = 0;
+ }
} ssao;
Effects() {}
@@ -1205,12 +1161,12 @@ public:
GLuint fbo;
GLuint color;
- Exposure() { fbo=0; }
+ Exposure() { fbo = 0; }
} exposure;
uint64_t last_exposure_tick;
- int width,height;
+ int width, height;
bool flags[RENDER_TARGET_FLAG_MAX];
@@ -1221,23 +1177,22 @@ public:
RenderTarget() {
- msaa=VS::VIEWPORT_MSAA_DISABLED;
- width=0;
- height=0;
- depth=0;
- fbo=0;
- exposure.fbo=0;
- buffers.fbo=0;
- used_in_frame=false;
-
+ msaa = VS::VIEWPORT_MSAA_DISABLED;
+ width = 0;
+ height = 0;
+ depth = 0;
+ fbo = 0;
+ exposure.fbo = 0;
+ buffers.fbo = 0;
+ used_in_frame = false;
- flags[RENDER_TARGET_VFLIP]=false;
- flags[RENDER_TARGET_TRANSPARENT]=false;
- flags[RENDER_TARGET_NO_3D]=false;
- flags[RENDER_TARGET_HDR]=true;
- flags[RENDER_TARGET_NO_SAMPLING]=false;
+ flags[RENDER_TARGET_VFLIP] = false;
+ flags[RENDER_TARGET_TRANSPARENT] = false;
+ flags[RENDER_TARGET_NO_3D] = false;
+ flags[RENDER_TARGET_HDR] = true;
+ flags[RENDER_TARGET_NO_SAMPLING] = false;
- last_exposure_tick=0;
+ last_exposure_tick = 0;
}
};
@@ -1247,12 +1202,12 @@ public:
void _render_target_allocate(RenderTarget *rt);
virtual RID render_target_create();
- virtual void render_target_set_size(RID p_render_target,int p_width, int p_height);
+ virtual void render_target_set_size(RID p_render_target, int p_width, int p_height);
virtual RID render_target_get_texture(RID p_render_target) const;
- virtual void render_target_set_flag(RID p_render_target,RenderTargetFlags p_flag,bool p_value);
+ virtual void render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value);
virtual bool render_target_renedered_in_frame(RID p_render_target);
- virtual void render_target_set_msaa(RID p_render_target,VS::ViewportMSAA p_msaa);
+ virtual void render_target_set_msaa(RID p_render_target, VS::ViewportMSAA p_msaa);
/* CANVAS SHADOW */
@@ -1282,13 +1237,12 @@ public:
RID_Owner<CanvasOccluder> canvas_occluder_owner;
virtual RID canvas_light_occluder_create();
- virtual void canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2>& p_lines);
+ virtual void canvas_light_occluder_set_polylines(RID p_occluder, const PoolVector<Vector2> &p_lines);
virtual VS::InstanceType get_base_type(RID p_rid) const;
virtual bool free(RID p_rid);
-
struct Frame {
RenderTarget *current_rt;
@@ -1305,12 +1259,11 @@ public:
void initialize();
void finalize();
- virtual bool has_os_feature(const String& p_feature) const;
+ virtual bool has_os_feature(const String &p_feature) const;
virtual void update_dirty_resources();
RasterizerStorageGLES3();
};
-
#endif // RASTERIZERSTORAGEGLES3_H
diff --git a/drivers/gles3/shader_compiler_gles3.cpp b/drivers/gles3/shader_compiler_gles3.cpp
index 260f1787c..12934a82e 100644
--- a/drivers/gles3/shader_compiler_gles3.cpp
+++ b/drivers/gles3/shader_compiler_gles3.cpp
@@ -35,8 +35,8 @@
static String _mktab(int p_level) {
String tb;
- for(int i=0;i<p_level;i++) {
- tb+="\t";
+ for (int i = 0; i < p_level; i++) {
+ tb += "\t";
}
return tb;
@@ -49,7 +49,7 @@ static String _typestr(SL::DataType p_type) {
static int _get_datatype_size(SL::DataType p_type) {
- switch(p_type) {
+ switch (p_type) {
case SL::TYPE_VOID: return 0;
case SL::TYPE_BOOL: return 4;
@@ -80,12 +80,9 @@ static int _get_datatype_size(SL::DataType p_type) {
ERR_FAIL_V(0);
}
-
-
static String _prestr(SL::DataPrecision p_pres) {
-
- switch(p_pres) {
+ switch (p_pres) {
case SL::PRECISION_LOWP: return "lowp ";
case SL::PRECISION_MEDIUMP: return "mediump ";
case SL::PRECISION_HIGHP: return "highp ";
@@ -94,89 +91,87 @@ static String _prestr(SL::DataPrecision p_pres) {
return "";
}
-
static String _opstr(SL::Operator p_op) {
return SL::get_operator_text(p_op);
}
-static String _mkid(const String& p_id) {
+static String _mkid(const String &p_id) {
- return "m_"+p_id;
+ return "m_" + p_id;
}
static String f2sp0(float p_float) {
- if (int(p_float)==p_float)
- return itos(p_float)+".0";
+ if (int(p_float) == p_float)
+ return itos(p_float) + ".0";
else
return rtoss(p_float);
}
-static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value>& p_values) {
+static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value> &p_values) {
- switch(p_type) {
- case SL::TYPE_BOOL: return p_values[0].boolean?"true":"false";
+ switch (p_type) {
+ case SL::TYPE_BOOL: return p_values[0].boolean ? "true" : "false";
case SL::TYPE_BVEC2:
case SL::TYPE_BVEC3:
case SL::TYPE_BVEC4: {
+ String text = "bvec" + itos(p_type - SL::TYPE_BOOL + 1) + "(";
+ for (int i = 0; i < p_values.size(); i++) {
+ if (i > 0)
+ text += ",";
- String text="bvec"+itos(p_type-SL::TYPE_BOOL+1)+"(";
- for(int i=0;i<p_values.size();i++) {
- if (i>0)
- text+=",";
-
- text+=p_values[i].boolean?"true":"false";
+ text += p_values[i].boolean ? "true" : "false";
}
- text+=")";
+ text += ")";
return text;
}
- case SL::TYPE_INT: return itos(p_values[0].sint);
+ case SL::TYPE_INT: return itos(p_values[0].sint);
case SL::TYPE_IVEC2:
case SL::TYPE_IVEC3:
case SL::TYPE_IVEC4: {
- String text="ivec"+itos(p_type-SL::TYPE_INT+1)+"(";
- for(int i=0;i<p_values.size();i++) {
- if (i>0)
- text+=",";
+ String text = "ivec" + itos(p_type - SL::TYPE_INT + 1) + "(";
+ for (int i = 0; i < p_values.size(); i++) {
+ if (i > 0)
+ text += ",";
- text+=itos(p_values[i].sint);
+ text += itos(p_values[i].sint);
}
- text+=")";
+ text += ")";
return text;
} break;
- case SL::TYPE_UINT: return itos(p_values[0].uint)+"u";
+ case SL::TYPE_UINT: return itos(p_values[0].uint) + "u";
case SL::TYPE_UVEC2:
case SL::TYPE_UVEC3:
- case SL::TYPE_UVEC4: {
+ case SL::TYPE_UVEC4: {
- String text="uvec"+itos(p_type-SL::TYPE_UINT+1)+"(";
- for(int i=0;i<p_values.size();i++) {
- if (i>0)
- text+=",";
+ String text = "uvec" + itos(p_type - SL::TYPE_UINT + 1) + "(";
+ for (int i = 0; i < p_values.size(); i++) {
+ if (i > 0)
+ text += ",";
- text+=itos(p_values[i].uint)+"u";
+ text += itos(p_values[i].uint) + "u";
}
- text+=")";
+ text += ")";
return text;
} break;
- case SL::TYPE_FLOAT: return f2sp0(p_values[0].real)+"f";
+ case SL::TYPE_FLOAT: return f2sp0(p_values[0].real) + "f";
case SL::TYPE_VEC2:
case SL::TYPE_VEC3:
- case SL::TYPE_VEC4: {
+ case SL::TYPE_VEC4: {
- String text="vec"+itos(p_type-SL::TYPE_FLOAT+1)+"(";
- for(int i=0;i<p_values.size();i++) {
- if (i>0)
- text+=",";
+ String text = "vec" + itos(p_type - SL::TYPE_FLOAT + 1) + "(";
+ for (int i = 0; i < p_values.size(); i++) {
+ if (i > 0)
+ text += ",";
- text+=f2sp0(p_values[i].real);
+ text += f2sp0(p_values[i].real);
}
- text+=")";
+ text += ")";
return text;
} break;
@@ -184,68 +179,68 @@ static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNo
}
}
-void ShaderCompilerGLES3::_dump_function_deps(SL::ShaderNode* p_node, const StringName& p_for_func, const Map<StringName,String>& p_func_code, String& r_to_add, Set<StringName> &added) {
+void ShaderCompilerGLES3::_dump_function_deps(SL::ShaderNode *p_node, const StringName &p_for_func, const Map<StringName, String> &p_func_code, String &r_to_add, Set<StringName> &added) {
- int fidx=-1;
+ int fidx = -1;
- for(int i=0;i<p_node->functions.size();i++) {
- if (p_node->functions[i].name==p_for_func) {
- fidx=i;
+ for (int i = 0; i < p_node->functions.size(); i++) {
+ if (p_node->functions[i].name == p_for_func) {
+ fidx = i;
break;
}
}
- ERR_FAIL_COND(fidx==-1);
+ ERR_FAIL_COND(fidx == -1);
- for (Set<StringName>::Element *E=p_node->functions[fidx].uses_function.front();E;E=E->next()) {
+ for (Set<StringName>::Element *E = p_node->functions[fidx].uses_function.front(); E; E = E->next()) {
if (added.has(E->get())) {
continue; //was added already
}
- _dump_function_deps(p_node,E->get(),p_func_code,r_to_add,added);
+ _dump_function_deps(p_node, E->get(), p_func_code, r_to_add, added);
- SL::FunctionNode *fnode=NULL;
+ SL::FunctionNode *fnode = NULL;
- for(int i=0;i<p_node->functions.size();i++) {
- if (p_node->functions[i].name==E->get()) {
- fnode=p_node->functions[i].function;
+ for (int i = 0; i < p_node->functions.size(); i++) {
+ if (p_node->functions[i].name == E->get()) {
+ fnode = p_node->functions[i].function;
break;
}
}
ERR_FAIL_COND(!fnode);
- r_to_add+="\n";
+ r_to_add += "\n";
String header;
- header=_typestr(fnode->return_type)+" "+_mkid(fnode->name)+"(";
- for(int i=0;i<fnode->arguments.size();i++) {
+ header = _typestr(fnode->return_type) + " " + _mkid(fnode->name) + "(";
+ for (int i = 0; i < fnode->arguments.size(); i++) {
- if (i>0)
- header+=", ";
- header+=_prestr(fnode->arguments[i].precision)+_typestr(fnode->arguments[i].type)+" "+_mkid(fnode->arguments[i].name);
+ if (i > 0)
+ header += ", ";
+ header += _prestr(fnode->arguments[i].precision) + _typestr(fnode->arguments[i].type) + " " + _mkid(fnode->arguments[i].name);
}
- header+=")\n";
- r_to_add+=header;
- r_to_add+=p_func_code[E->get()];
+ header += ")\n";
+ r_to_add += header;
+ r_to_add += p_func_code[E->get()];
added.insert(E->get());
}
}
-String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, GeneratedCode& r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions) {
+String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions) {
String code;
- switch(p_node->type) {
+ switch (p_node->type) {
case SL::Node::TYPE_SHADER: {
- SL::ShaderNode *pnode=(SL::ShaderNode*)p_node;
+ SL::ShaderNode *pnode = (SL::ShaderNode *)p_node;
- for(int i=0;i<pnode->render_modes.size();i++) {
+ for (int i = 0; i < pnode->render_modes.size(); i++) {
if (p_default_actions.render_mode_defines.has(pnode->render_modes[i]) && !used_rmode_defines.has(pnode->render_modes[i])) {
@@ -254,20 +249,19 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
}
if (p_actions.render_mode_flags.has(pnode->render_modes[i])) {
- *p_actions.render_mode_flags[pnode->render_modes[i]]=true;
+ *p_actions.render_mode_flags[pnode->render_modes[i]] = true;
}
if (p_actions.render_mode_values.has(pnode->render_modes[i])) {
- Pair<int*,int> &p = p_actions.render_mode_values[pnode->render_modes[i]];
- *p.first=p.second;
+ Pair<int *, int> &p = p_actions.render_mode_values[pnode->render_modes[i]];
+ *p.first = p.second;
}
}
+ int max_texture_uniforms = 0;
+ int max_uniforms = 0;
- int max_texture_uniforms=0;
- int max_uniforms=0;
-
- for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+ for (Map<StringName, SL::ShaderNode::Uniform>::Element *E = pnode->uniforms.front(); E; E = E->next()) {
if (SL::is_sampler_type(E->get().type))
max_texture_uniforms++;
else
@@ -284,66 +278,62 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
uniform_alignments.resize(max_uniforms);
uniform_defines.resize(max_uniforms);
- for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
+ for (Map<StringName, SL::ShaderNode::Uniform>::Element *E = pnode->uniforms.front(); E; E = E->next()) {
String ucode;
if (SL::is_sampler_type(E->get().type)) {
- ucode="uniform ";
+ ucode = "uniform ";
}
- ucode+=_prestr(E->get().precission);
- ucode+=_typestr(E->get().type);
- ucode+=" "+_mkid(E->key());
- ucode+=";\n";
+ ucode += _prestr(E->get().precission);
+ ucode += _typestr(E->get().type);
+ ucode += " " + _mkid(E->key());
+ ucode += ";\n";
if (SL::is_sampler_type(E->get().type)) {
- r_gen_code.vertex_global+=ucode;
- r_gen_code.fragment_global+=ucode;
- r_gen_code.texture_uniforms[E->get().texture_order]=_mkid(E->key());
- r_gen_code.texture_hints[E->get().texture_order]=E->get().hint;
+ r_gen_code.vertex_global += ucode;
+ r_gen_code.fragment_global += ucode;
+ r_gen_code.texture_uniforms[E->get().texture_order] = _mkid(E->key());
+ r_gen_code.texture_hints[E->get().texture_order] = E->get().hint;
} else {
if (r_gen_code.uniforms.empty()) {
r_gen_code.defines.push_back(String("#define USE_MATERIAL\n").ascii());
}
- uniform_defines[E->get().order]=ucode;
- uniform_sizes[E->get().order]=_get_datatype_size(E->get().type);
- uniform_alignments[E->get().order]=MIN(16,_get_datatype_size(E->get().type));
+ uniform_defines[E->get().order] = ucode;
+ uniform_sizes[E->get().order] = _get_datatype_size(E->get().type);
+ uniform_alignments[E->get().order] = MIN(16, _get_datatype_size(E->get().type));
}
- p_actions.uniforms->insert(E->key(),E->get());
-
+ p_actions.uniforms->insert(E->key(), E->get());
}
- for(int i=0;i<max_uniforms;i++) {
- r_gen_code.uniforms+=uniform_defines[i];
+ for (int i = 0; i < max_uniforms; i++) {
+ r_gen_code.uniforms += uniform_defines[i];
}
// add up
- for(int i=0;i<uniform_sizes.size();i++) {
+ for (int i = 0; i < uniform_sizes.size(); i++) {
- if (i>0) {
+ if (i > 0) {
- int align = uniform_sizes[i-1] % uniform_alignments[i];
- if (align!=0) {
- uniform_sizes[i-1]+=uniform_alignments[i]-align;
+ int align = uniform_sizes[i - 1] % uniform_alignments[i];
+ if (align != 0) {
+ uniform_sizes[i - 1] += uniform_alignments[i] - align;
}
- uniform_sizes[i]=uniform_sizes[i]+uniform_sizes[i-1];
-
+ uniform_sizes[i] = uniform_sizes[i] + uniform_sizes[i - 1];
}
}
//offset
r_gen_code.uniform_offsets.resize(uniform_sizes.size());
- for(int i=0;i<uniform_sizes.size();i++) {
+ for (int i = 0; i < uniform_sizes.size(); i++) {
- if (i>0)
- r_gen_code.uniform_offsets[i]=uniform_sizes[i-1];
+ if (i > 0)
+ r_gen_code.uniform_offsets[i] = uniform_sizes[i - 1];
else
- r_gen_code.uniform_offsets[i]=0;
-
-
+ r_gen_code.uniform_offsets[i] = 0;
}
-/*
+ /*
for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
if (SL::is_sampler_type(E->get().type)) {
@@ -356,28 +346,28 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
*/
if (uniform_sizes.size()) {
- r_gen_code.uniform_total_size=uniform_sizes[ uniform_sizes.size() -1 ];
+ r_gen_code.uniform_total_size = uniform_sizes[uniform_sizes.size() - 1];
} else {
- r_gen_code.uniform_total_size=0;
+ r_gen_code.uniform_total_size = 0;
}
- for(Map<StringName,SL::ShaderNode::Varying>::Element *E=pnode->varyings.front();E;E=E->next()) {
+ for (Map<StringName, SL::ShaderNode::Varying>::Element *E = pnode->varyings.front(); E; E = E->next()) {
String vcode;
- vcode+=_prestr(E->get().precission);
- vcode+=_typestr(E->get().type);
- vcode+=" "+String(E->key());
- vcode+=";\n";
- r_gen_code.vertex_global+="out "+vcode;
- r_gen_code.fragment_global+="in "+vcode;
+ vcode += _prestr(E->get().precission);
+ vcode += _typestr(E->get().type);
+ vcode += " " + String(E->key());
+ vcode += ";\n";
+ r_gen_code.vertex_global += "out " + vcode;
+ r_gen_code.fragment_global += "in " + vcode;
}
- Map<StringName,String> function_code;
+ Map<StringName, String> function_code;
//code for functions
- for(int i=0;i<pnode->functions.size();i++) {
- SL::FunctionNode *fnode=pnode->functions[i].function;
- function_code[fnode->name]=_dump_node_code(fnode->body,p_level+1,r_gen_code,p_actions,p_default_actions);
+ for (int i = 0; i < pnode->functions.size(); i++) {
+ SL::FunctionNode *fnode = pnode->functions[i].function;
+ function_code[fnode->name] = _dump_node_code(fnode->body, p_level + 1, r_gen_code, p_actions, p_default_actions);
}
//place functions in actual code
@@ -385,28 +375,28 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
Set<StringName> added_vtx;
Set<StringName> added_fragment; //share for light
- for(int i=0;i<pnode->functions.size();i++) {
+ for (int i = 0; i < pnode->functions.size(); i++) {
- SL::FunctionNode *fnode=pnode->functions[i].function;
+ SL::FunctionNode *fnode = pnode->functions[i].function;
- current_func_name=fnode->name;
+ current_func_name = fnode->name;
- if (fnode->name=="vertex") {
+ if (fnode->name == "vertex") {
- _dump_function_deps(pnode,fnode->name,function_code,r_gen_code.vertex_global,added_vtx);
- r_gen_code.vertex=function_code["vertex"];
+ _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.vertex_global, added_vtx);
+ r_gen_code.vertex = function_code["vertex"];
}
- if (fnode->name=="fragment") {
+ if (fnode->name == "fragment") {
- _dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
- r_gen_code.fragment=function_code["fragment"];
+ _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.fragment_global, added_fragment);
+ r_gen_code.fragment = function_code["fragment"];
}
- if (fnode->name=="light") {
+ if (fnode->name == "light") {
- _dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
- r_gen_code.light=function_code["light"];
+ _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.fragment_global, added_fragment);
+ r_gen_code.light = function_code["light"];
}
}
@@ -416,72 +406,70 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
} break;
case SL::Node::TYPE_BLOCK: {
- SL::BlockNode *bnode=(SL::BlockNode*)p_node;
+ SL::BlockNode *bnode = (SL::BlockNode *)p_node;
//variables
- code+=_mktab(p_level-1)+"{\n";
- for(Map<StringName,SL::BlockNode::Variable>::Element *E=bnode->variables.front();E;E=E->next()) {
+ code += _mktab(p_level - 1) + "{\n";
+ for (Map<StringName, SL::BlockNode::Variable>::Element *E = bnode->variables.front(); E; E = E->next()) {
- code+=_mktab(p_level)+_prestr(E->get().precision)+_typestr(E->get().type)+" "+_mkid(E->key())+";\n";
+ code += _mktab(p_level) + _prestr(E->get().precision) + _typestr(E->get().type) + " " + _mkid(E->key()) + ";\n";
}
- for(int i=0;i<bnode->statements.size();i++) {
+ for (int i = 0; i < bnode->statements.size(); i++) {
- String scode = _dump_node_code(bnode->statements[i],p_level,r_gen_code,p_actions,p_default_actions);
+ String scode = _dump_node_code(bnode->statements[i], p_level, r_gen_code, p_actions, p_default_actions);
- if (bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW || bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW) {
+ if (bnode->statements[i]->type == SL::Node::TYPE_CONTROL_FLOW || bnode->statements[i]->type == SL::Node::TYPE_CONTROL_FLOW) {
// FIXME: if (A || A) ? I am hesitant to delete one of them, could be copy-paste error.
- code+=scode; //use directly
+ code += scode; //use directly
} else {
- code+=_mktab(p_level)+scode+";\n";
+ code += _mktab(p_level) + scode + ";\n";
}
}
- code+=_mktab(p_level-1)+"}\n";
-
+ code += _mktab(p_level - 1) + "}\n";
} break;
case SL::Node::TYPE_VARIABLE: {
- SL::VariableNode *vnode=(SL::VariableNode*)p_node;
+ SL::VariableNode *vnode = (SL::VariableNode *)p_node;
if (p_default_actions.usage_defines.has(vnode->name) && !used_name_defines.has(vnode->name)) {
String define = p_default_actions.usage_defines[vnode->name];
if (define.begins_with("@")) {
- define = p_default_actions.usage_defines[define.substr(1,define.length())];
+ define = p_default_actions.usage_defines[define.substr(1, define.length())];
}
r_gen_code.defines.push_back(define.utf8());
used_name_defines.insert(vnode->name);
}
if (p_actions.usage_flag_pointers.has(vnode->name) && !used_flag_pointers.has(vnode->name)) {
- *p_actions.usage_flag_pointers[vnode->name]=true;
+ *p_actions.usage_flag_pointers[vnode->name] = true;
used_flag_pointers.insert(vnode->name);
}
if (p_default_actions.renames.has(vnode->name))
- code=p_default_actions.renames[vnode->name];
+ code = p_default_actions.renames[vnode->name];
else
- code=_mkid(vnode->name);
+ code = _mkid(vnode->name);
- if (vnode->name==time_name) {
- if (current_func_name==vertex_name) {
- r_gen_code.uses_vertex_time=true;
+ if (vnode->name == time_name) {
+ if (current_func_name == vertex_name) {
+ r_gen_code.uses_vertex_time = true;
}
- if (current_func_name==fragment_name) {
- r_gen_code.uses_fragment_time=true;
+ if (current_func_name == fragment_name) {
+ r_gen_code.uses_fragment_time = true;
}
}
} break;
case SL::Node::TYPE_CONSTANT: {
- SL::ConstantNode *cnode=(SL::ConstantNode*)p_node;
- return get_constant_text(cnode->datatype,cnode->values);
+ SL::ConstantNode *cnode = (SL::ConstantNode *)p_node;
+ return get_constant_text(cnode->datatype, cnode->values);
} break;
case SL::Node::TYPE_OPERATOR: {
- SL::OperatorNode *onode=(SL::OperatorNode*)p_node;
-
+ SL::OperatorNode *onode = (SL::OperatorNode *)p_node;
- switch(onode->op) {
+ switch (onode->op) {
case SL::OP_ASSIGN:
case SL::OP_ASSIGN_ADD:
@@ -494,276 +482,259 @@ String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, Gener
case SL::OP_ASSIGN_BIT_AND:
case SL::OP_ASSIGN_BIT_OR:
case SL::OP_ASSIGN_BIT_XOR:
- code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions);
+ code = _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions) + _opstr(onode->op) + _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions);
break;
case SL::OP_BIT_INVERT:
case SL::OP_NEGATE:
case SL::OP_NOT:
case SL::OP_DECREMENT:
case SL::OP_INCREMENT:
- code=_opstr(onode->op)+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions);
+ code = _opstr(onode->op) + _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions);
break;
case SL::OP_POST_DECREMENT:
case SL::OP_POST_INCREMENT:
- code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op);
+ code = _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions) + _opstr(onode->op);
break;
case SL::OP_CALL:
case SL::OP_CONSTRUCT: {
- ERR_FAIL_COND_V(onode->arguments[0]->type!=SL::Node::TYPE_VARIABLE,String());
+ ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::TYPE_VARIABLE, String());
- SL::VariableNode *vnode=(SL::VariableNode*)onode->arguments[0];
+ SL::VariableNode *vnode = (SL::VariableNode *)onode->arguments[0];
- if (onode->op==SL::OP_CONSTRUCT) {
- code+=String(vnode->name);
+ if (onode->op == SL::OP_CONSTRUCT) {
+ code += String(vnode->name);
} else {
if (internal_functions.has(vnode->name)) {
- code+=vnode->name;
+ code += vnode->name;
} else if (p_default_actions.renames.has(vnode->name)) {
- code+=p_default_actions.renames[vnode->name];
+ code += p_default_actions.renames[vnode->name];
} else {
- code+=_mkid(vnode->name);
+ code += _mkid(vnode->name);
}
}
- code+="(";
+ code += "(";
- for(int i=1;i<onode->arguments.size();i++) {
- if (i>1)
- code+=", ";
- code+=_dump_node_code(onode->arguments[i],p_level,r_gen_code,p_actions,p_default_actions);
+ for (int i = 1; i < onode->arguments.size(); i++) {
+ if (i > 1)
+ code += ", ";
+ code += _dump_node_code(onode->arguments[i], p_level, r_gen_code, p_actions, p_default_actions);
}
- code+=")";
+ code += ")";
} break;
default: {
- code="("+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions)+")";
+ code = "(" + _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions) + _opstr(onode->op) + _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions) + ")";
break;
-
}
}
} break;
case SL::Node::TYPE_CONTROL_FLOW: {
- SL::ControlFlowNode *cfnode=(SL::ControlFlowNode*)p_node;
- if (cfnode->flow_op==SL::FLOW_OP_IF) {
+ SL::ControlFlowNode *cfnode = (SL::ControlFlowNode *)p_node;
+ if (cfnode->flow_op == SL::FLOW_OP_IF) {
- code+=_mktab(p_level)+"if ("+_dump_node_code(cfnode->expressions[0],p_level,r_gen_code,p_actions,p_default_actions)+")\n";
- code+=_dump_node_code(cfnode->blocks[0],p_level+1,r_gen_code,p_actions,p_default_actions);
- if (cfnode->blocks.size()==2) {
+ code += _mktab(p_level) + "if (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions) + ")\n";
+ code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions);
+ if (cfnode->blocks.size() == 2) {
- code+=_mktab(p_level)+"else\n";
- code+=_dump_node_code(cfnode->blocks[1],p_level+1,r_gen_code,p_actions,p_default_actions);
+ code += _mktab(p_level) + "else\n";
+ code += _dump_node_code(cfnode->blocks[1], p_level + 1, r_gen_code, p_actions, p_default_actions);
}
-
- } else if (cfnode->flow_op==SL::FLOW_OP_RETURN) {
+ } else if (cfnode->flow_op == SL::FLOW_OP_RETURN) {
if (cfnode->blocks.size()) {
- code="return "+_dump_node_code(cfnode->blocks[0],p_level,r_gen_code,p_actions,p_default_actions);
+ code = "return " + _dump_node_code(cfnode->blocks[0], p_level, r_gen_code, p_actions, p_default_actions);
} else {
- code="return";
+ code = "return";
}
}
} break;
case SL::Node::TYPE_MEMBER: {
- SL::MemberNode *mnode=(SL::MemberNode*)p_node;
- code=_dump_node_code(mnode->owner,p_level,r_gen_code,p_actions,p_default_actions)+"."+mnode->name;
+ SL::MemberNode *mnode = (SL::MemberNode *)p_node;
+ code = _dump_node_code(mnode->owner, p_level, r_gen_code, p_actions, p_default_actions) + "." + mnode->name;
} break;
}
return code;
-
}
+Error ShaderCompilerGLES3::compile(VS::ShaderMode p_mode, const String &p_code, IdentifierActions *p_actions, const String &p_path, GeneratedCode &r_gen_code) {
-Error ShaderCompilerGLES3::compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String &p_path,GeneratedCode& r_gen_code) {
-
-
-
- Error err = parser.compile(p_code,ShaderTypes::get_singleton()->get_functions(p_mode),ShaderTypes::get_singleton()->get_modes(p_mode));
+ Error err = parser.compile(p_code, ShaderTypes::get_singleton()->get_functions(p_mode), ShaderTypes::get_singleton()->get_modes(p_mode));
- if (err!=OK) {
+ if (err != OK) {
#if 1
Vector<String> shader = p_code.split("\n");
- for(int i=0;i<shader.size();i++) {
- print_line(itos(i)+" "+shader[i]);
+ for (int i = 0; i < shader.size(); i++) {
+ print_line(itos(i) + " " + shader[i]);
}
#endif
- _err_print_error(NULL,p_path.utf8().get_data(),parser.get_error_line(),parser.get_error_text().utf8().get_data(),ERR_HANDLER_SHADER);
+ _err_print_error(NULL, p_path.utf8().get_data(), parser.get_error_line(), parser.get_error_text().utf8().get_data(), ERR_HANDLER_SHADER);
return err;
}
r_gen_code.defines.clear();
- r_gen_code.vertex=String();
- r_gen_code.vertex_global=String();
- r_gen_code.fragment=String();
- r_gen_code.fragment_global=String();
- r_gen_code.light=String();
- r_gen_code.uses_fragment_time=false;
- r_gen_code.uses_vertex_time=false;
-
-
+ r_gen_code.vertex = String();
+ r_gen_code.vertex_global = String();
+ r_gen_code.fragment = String();
+ r_gen_code.fragment_global = String();
+ r_gen_code.light = String();
+ r_gen_code.uses_fragment_time = false;
+ r_gen_code.uses_vertex_time = false;
used_name_defines.clear();
used_rmode_defines.clear();
used_flag_pointers.clear();
- _dump_node_code(parser.get_shader(),1,r_gen_code,*p_actions,actions[p_mode]);
+ _dump_node_code(parser.get_shader(), 1, r_gen_code, *p_actions, actions[p_mode]);
return OK;
-
}
-
ShaderCompilerGLES3::ShaderCompilerGLES3() {
/** CANVAS ITEM SHADER **/
- actions[VS::SHADER_CANVAS_ITEM].renames["SRC_VERTEX"]="vertex";
- actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX"]="outvec.xy";
- actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX_COLOR"]="vertex_color";
- actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
- actions[VS::SHADER_CANVAS_ITEM].renames["POINT_SIZE"]="gl_PointSize";
+ actions[VS::SHADER_CANVAS_ITEM].renames["SRC_VERTEX"] = "vertex";
+ actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX"] = "outvec.xy";
+ actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX_COLOR"] = "vertex_color";
+ actions[VS::SHADER_CANVAS_ITEM].renames["UV"] = "uv_interp";
+ actions[VS::SHADER_CANVAS_ITEM].renames["POINT_SIZE"] = "gl_PointSize";
- actions[VS::SHADER_CANVAS_ITEM].renames["WORLD_MATRIX"]="modelview_matrix";
- actions[VS::SHADER_CANVAS_ITEM].renames["PROJECTION_MATRIX"]="projection_matrix";
- actions[VS::SHADER_CANVAS_ITEM].renames["EXTRA_MATRIX"]=="extra_matrix";
- actions[VS::SHADER_CANVAS_ITEM].renames["TIME"]="time";
+ actions[VS::SHADER_CANVAS_ITEM].renames["WORLD_MATRIX"] = "modelview_matrix";
+ actions[VS::SHADER_CANVAS_ITEM].renames["PROJECTION_MATRIX"] = "projection_matrix";
+ actions[VS::SHADER_CANVAS_ITEM].renames["EXTRA_MATRIX"] == "extra_matrix";
+ actions[VS::SHADER_CANVAS_ITEM].renames["TIME"] = "time";
- actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
- actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL"]="normal";
- actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP"]="normal_map";
- actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP_DEPTH"]="normal_depth";
- actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
- actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
- actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE"]="color_texture";
- actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE_PIXEL_SIZE"]="color_texpixel_size";
- actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_UV"]="screen_uv";
- actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_TEXTURE"]="screen_texture";
- actions[VS::SHADER_CANVAS_ITEM].renames["POINT_COORD"]="gl_PointCoord";
+ actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"] = "color";
+ actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL"] = "normal";
+ actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP"] = "normal_map";
+ actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP_DEPTH"] = "normal_depth";
+ actions[VS::SHADER_CANVAS_ITEM].renames["UV"] = "uv_interp";
+ actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"] = "color";
+ actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE"] = "color_texture";
+ actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE_PIXEL_SIZE"] = "color_texpixel_size";
+ actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_UV"] = "screen_uv";
+ actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_TEXTURE"] = "screen_texture";
+ actions[VS::SHADER_CANVAS_ITEM].renames["POINT_COORD"] = "gl_PointCoord";
- actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_VEC"]="light_vec";
- actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_HEIGHT"]="light_height";
- actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_COLOR"]="light_color";
- actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_UV"]="light_uv";
+ actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_VEC"] = "light_vec";
+ actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_HEIGHT"] = "light_height";
+ actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_COLOR"] = "light_color";
+ actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_UV"] = "light_uv";
//actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_SHADOW_COLOR"]="light_shadow_color";
- actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT"]="light";
- actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_COLOR"]="shadow_color";
+ actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT"] = "light";
+ actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_COLOR"] = "shadow_color";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["COLOR"]="#define COLOR_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_TEXTURE"]="#define SCREEN_TEXTURE_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_UV"]="#define SCREEN_UV_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMAL"]="#define NORMAL_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMALMAP"]="#define NORMALMAP_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].usage_defines["SHADOW_COLOR"]="#define SHADOW_COLOR_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["COLOR"] = "#define COLOR_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMAL"] = "#define NORMAL_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMALMAP"] = "#define NORMALMAP_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].usage_defines["SHADOW_COLOR"] = "#define SHADOW_COLOR_USED\n";
- actions[VS::SHADER_CANVAS_ITEM].render_mode_defines["skip_transform"]="#define SKIP_TRANSFORM_USED\n";
+ actions[VS::SHADER_CANVAS_ITEM].render_mode_defines["skip_transform"] = "#define SKIP_TRANSFORM_USED\n";
/** SPATIAL SHADER **/
+ actions[VS::SHADER_SPATIAL].renames["WORLD_MATRIX"] = "world_transform";
+ actions[VS::SHADER_SPATIAL].renames["INV_CAMERA_MATRIX"] = "camera_inverse_matrix";
+ actions[VS::SHADER_SPATIAL].renames["PROJECTION_MATRIX"] = "projection_matrix";
- actions[VS::SHADER_SPATIAL].renames["WORLD_MATRIX"]="world_transform";
- actions[VS::SHADER_SPATIAL].renames["INV_CAMERA_MATRIX"]="camera_inverse_matrix";
- actions[VS::SHADER_SPATIAL].renames["PROJECTION_MATRIX"]="projection_matrix";
-
-
- actions[VS::SHADER_SPATIAL].renames["VERTEX"]="vertex.xyz";
- actions[VS::SHADER_SPATIAL].renames["NORMAL"]="normal";
- actions[VS::SHADER_SPATIAL].renames["TANGENT"]="tangent";
- actions[VS::SHADER_SPATIAL].renames["BINORMAL"]="binormal";
- actions[VS::SHADER_SPATIAL].renames["UV"]="uv_interp";
- actions[VS::SHADER_SPATIAL].renames["UV2"]="uv2_interp";
- actions[VS::SHADER_SPATIAL].renames["COLOR"]="color_interp";
- actions[VS::SHADER_SPATIAL].renames["POINT_SIZE"]="gl_PointSize";
+ actions[VS::SHADER_SPATIAL].renames["VERTEX"] = "vertex.xyz";
+ actions[VS::SHADER_SPATIAL].renames["NORMAL"] = "normal";
+ actions[VS::SHADER_SPATIAL].renames["TANGENT"] = "tangent";
+ actions[VS::SHADER_SPATIAL].renames["BINORMAL"] = "binormal";
+ actions[VS::SHADER_SPATIAL].renames["UV"] = "uv_interp";
+ actions[VS::SHADER_SPATIAL].renames["UV2"] = "uv2_interp";
+ actions[VS::SHADER_SPATIAL].renames["COLOR"] = "color_interp";
+ actions[VS::SHADER_SPATIAL].renames["POINT_SIZE"] = "gl_PointSize";
//actions[VS::SHADER_SPATIAL].renames["INSTANCE_ID"]=ShaderLanguage::TYPE_INT;
//builtins
- actions[VS::SHADER_SPATIAL].renames["TIME"]="time";
+ actions[VS::SHADER_SPATIAL].renames["TIME"] = "time";
//actions[VS::SHADER_SPATIAL].renames["VIEWPORT_SIZE"]=ShaderLanguage::TYPE_VEC2;
- actions[VS::SHADER_SPATIAL].renames["FRAGCOORD"]="gl_FragCoord";
- actions[VS::SHADER_SPATIAL].renames["FRONT_FACING"]="gl_FrotFacing";
- actions[VS::SHADER_SPATIAL].renames["NORMALMAP"]="normalmap";
- actions[VS::SHADER_SPATIAL].renames["NORMALMAP_DEPTH"]="normaldepth";
- actions[VS::SHADER_SPATIAL].renames["ALBEDO"]="albedo";
- actions[VS::SHADER_SPATIAL].renames["ALPHA"]="alpha";
- actions[VS::SHADER_SPATIAL].renames["SPECULAR"]="specular";
- actions[VS::SHADER_SPATIAL].renames["ROUGHNESS"]="roughness";
- actions[VS::SHADER_SPATIAL].renames["RIM"]="rim";
- actions[VS::SHADER_SPATIAL].renames["RIM_TINT"]="rim_tint";
- actions[VS::SHADER_SPATIAL].renames["CLEARCOAT"]="clearcoat";
- actions[VS::SHADER_SPATIAL].renames["CLEARCOAT_GLOSS"]="clearcoat_gloss";
- actions[VS::SHADER_SPATIAL].renames["ANISOTROPY"]="anisotropy";
- actions[VS::SHADER_SPATIAL].renames["ANISOTROPY_FLOW"]="anisotropy_flow";
- actions[VS::SHADER_SPATIAL].renames["SSS_SPREAD"]="sss_spread";
- actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"]="sss_strength";
- actions[VS::SHADER_SPATIAL].renames["AO"]="ao";
- actions[VS::SHADER_SPATIAL].renames["EMISSION"]="emission";
- actions[VS::SHADER_SPATIAL].renames["DISCARD"]="_discard";
+ actions[VS::SHADER_SPATIAL].renames["FRAGCOORD"] = "gl_FragCoord";
+ actions[VS::SHADER_SPATIAL].renames["FRONT_FACING"] = "gl_FrotFacing";
+ actions[VS::SHADER_SPATIAL].renames["NORMALMAP"] = "normalmap";
+ actions[VS::SHADER_SPATIAL].renames["NORMALMAP_DEPTH"] = "normaldepth";
+ actions[VS::SHADER_SPATIAL].renames["ALBEDO"] = "albedo";
+ actions[VS::SHADER_SPATIAL].renames["ALPHA"] = "alpha";
+ actions[VS::SHADER_SPATIAL].renames["SPECULAR"] = "specular";
+ actions[VS::SHADER_SPATIAL].renames["ROUGHNESS"] = "roughness";
+ actions[VS::SHADER_SPATIAL].renames["RIM"] = "rim";
+ actions[VS::SHADER_SPATIAL].renames["RIM_TINT"] = "rim_tint";
+ actions[VS::SHADER_SPATIAL].renames["CLEARCOAT"] = "clearcoat";
+ actions[VS::SHADER_SPATIAL].renames["CLEARCOAT_GLOSS"] = "clearcoat_gloss";
+ actions[VS::SHADER_SPATIAL].renames["ANISOTROPY"] = "anisotropy";
+ actions[VS::SHADER_SPATIAL].renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
+ actions[VS::SHADER_SPATIAL].renames["SSS_SPREAD"] = "sss_spread";
+ actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"] = "sss_strength";
+ actions[VS::SHADER_SPATIAL].renames["AO"] = "ao";
+ actions[VS::SHADER_SPATIAL].renames["EMISSION"] = "emission";
+ actions[VS::SHADER_SPATIAL].renames["DISCARD"] = "_discard";
//actions[VS::SHADER_SPATIAL].renames["SCREEN_UV"]=ShaderLanguage::TYPE_VEC2;
- actions[VS::SHADER_SPATIAL].renames["POINT_COORD"]="gl_PointCoord";
-
-
- actions[VS::SHADER_SPATIAL].usage_defines["TANGENT"]="#define ENABLE_TANGENT_INTERP\n";
- actions[VS::SHADER_SPATIAL].usage_defines["BINORMAL"]="@TANGENT";
- actions[VS::SHADER_SPATIAL].usage_defines["RIM"]="#define LIGHT_USE_RIM\n";
- actions[VS::SHADER_SPATIAL].usage_defines["RIM_TINT"]="@RIM";
- actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT"]="#define LIGHT_USE_CLEARCOAT\n";
- actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT_GLOSS"]="@CLEARCOAT";
- actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY"]="#define LIGHT_USE_ANISOTROPY\n";
- actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY_FLOW"]="@ANISOTROPY";
- actions[VS::SHADER_SPATIAL].usage_defines["AO"]="#define ENABLE_AO\n";
- actions[VS::SHADER_SPATIAL].usage_defines["UV"]="#define ENABLE_UV_INTERP\n";
- actions[VS::SHADER_SPATIAL].usage_defines["UV2"]="#define ENABLE_UV2_INTERP\n";
- actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP"]="#define ENABLE_NORMALMAP\n";
- actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP_DEPTH"]="@NORMALMAP";
- actions[VS::SHADER_SPATIAL].usage_defines["COLOR"]="#define ENABLE_COLOR_INTERP\n";
+ actions[VS::SHADER_SPATIAL].renames["POINT_COORD"] = "gl_PointCoord";
- actions[VS::SHADER_SPATIAL].usage_defines["SSS_STRENGTH"]="#define ENABLE_SSS_MOTION\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["TANGENT"] = "#define ENABLE_TANGENT_INTERP\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["BINORMAL"] = "@TANGENT";
+ actions[VS::SHADER_SPATIAL].usage_defines["RIM"] = "#define LIGHT_USE_RIM\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["RIM_TINT"] = "@RIM";
+ actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT"] = "#define LIGHT_USE_CLEARCOAT\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT_GLOSS"] = "@CLEARCOAT";
+ actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY"] = "#define LIGHT_USE_ANISOTROPY\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
+ actions[VS::SHADER_SPATIAL].usage_defines["AO"] = "#define ENABLE_AO\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["UV"] = "#define ENABLE_UV_INTERP\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["UV2"] = "#define ENABLE_UV2_INTERP\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP"] = "#define ENABLE_NORMALMAP\n";
+ actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP_DEPTH"] = "@NORMALMAP";
+ actions[VS::SHADER_SPATIAL].usage_defines["COLOR"] = "#define ENABLE_COLOR_INTERP\n";
- actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"]="sss_strength";
+ actions[VS::SHADER_SPATIAL].usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS_MOTION\n";
+ actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"] = "sss_strength";
- actions[VS::SHADER_SPATIAL].render_mode_defines["skip_transform"]="#define SKIP_TRANSFORM_USED\n";
-
+ actions[VS::SHADER_SPATIAL].render_mode_defines["skip_transform"] = "#define SKIP_TRANSFORM_USED\n";
/* PARTICLES SHADER */
- actions[VS::SHADER_PARTICLES].renames["COLOR"]="color";
- actions[VS::SHADER_PARTICLES].renames["VELOCITY"]="out_velocity_active.xyz";
- actions[VS::SHADER_PARTICLES].renames["MASS"]="mass";
- actions[VS::SHADER_PARTICLES].renames["ACTIVE"]="active";
- actions[VS::SHADER_PARTICLES].renames["RESTART"]="restart";
- actions[VS::SHADER_PARTICLES].renames["CUSTOM"]="out_custom";
- actions[VS::SHADER_PARTICLES].renames["TRANSFORM"]="xform";
- actions[VS::SHADER_PARTICLES].renames["TIME"]="time";
- actions[VS::SHADER_PARTICLES].renames["LIFETIME"]="lifetime";
- actions[VS::SHADER_PARTICLES].renames["DELTA"]="delta";
- actions[VS::SHADER_PARTICLES].renames["SEED"]="seed";
- actions[VS::SHADER_PARTICLES].renames["ORIGIN"]="origin";
- actions[VS::SHADER_PARTICLES].renames["INDEX"]="index";
-
- actions[VS::SHADER_SPATIAL].render_mode_defines["disable_force"]="#define DISABLE_FORCE\n";
- actions[VS::SHADER_SPATIAL].render_mode_defines["disable_velocity"]="#define DISABLE_VELOCITY\n";
-
+ actions[VS::SHADER_PARTICLES].renames["COLOR"] = "color";
+ actions[VS::SHADER_PARTICLES].renames["VELOCITY"] = "out_velocity_active.xyz";
+ actions[VS::SHADER_PARTICLES].renames["MASS"] = "mass";
+ actions[VS::SHADER_PARTICLES].renames["ACTIVE"] = "active";
+ actions[VS::SHADER_PARTICLES].renames["RESTART"] = "restart";
+ actions[VS::SHADER_PARTICLES].renames["CUSTOM"] = "out_custom";
+ actions[VS::SHADER_PARTICLES].renames["TRANSFORM"] = "xform";
+ actions[VS::SHADER_PARTICLES].renames["TIME"] = "time";
+ actions[VS::SHADER_PARTICLES].renames["LIFETIME"] = "lifetime";
+ actions[VS::SHADER_PARTICLES].renames["DELTA"] = "delta";
+ actions[VS::SHADER_PARTICLES].renames["SEED"] = "seed";
+ actions[VS::SHADER_PARTICLES].renames["ORIGIN"] = "origin";
+ actions[VS::SHADER_PARTICLES].renames["INDEX"] = "index";
- vertex_name="vertex";
- fragment_name="fragment";
- time_name="TIME";
+ actions[VS::SHADER_SPATIAL].render_mode_defines["disable_force"] = "#define DISABLE_FORCE\n";
+ actions[VS::SHADER_SPATIAL].render_mode_defines["disable_velocity"] = "#define DISABLE_VELOCITY\n";
+ vertex_name = "vertex";
+ fragment_name = "fragment";
+ time_name = "TIME";
List<String> func_list;
ShaderLanguage::get_builtin_funcs(&func_list);
- for (List<String>::Element *E=func_list.front();E;E=E->next()) {
+ for (List<String>::Element *E = func_list.front(); E; E = E->next()) {
internal_functions.insert(E->get());
}
}
diff --git a/drivers/gles3/shader_compiler_gles3.h b/drivers/gles3/shader_compiler_gles3.h
index bbdfc7865..44d6b3a34 100644
--- a/drivers/gles3/shader_compiler_gles3.h
+++ b/drivers/gles3/shader_compiler_gles3.h
@@ -29,20 +29,20 @@
#ifndef SHADERCOMPILERGLES3_H
#define SHADERCOMPILERGLES3_H
+#include "pair.h"
#include "servers/visual/shader_language.h"
#include "servers/visual/shader_types.h"
#include "servers/visual_server.h"
-#include "pair.h"
class ShaderCompilerGLES3 {
public:
struct IdentifierActions {
- Map<StringName,Pair<int*,int> > render_mode_values;
- Map<StringName,bool*> render_mode_flags;
- Map<StringName,bool*> usage_flag_pointers;
+ Map<StringName, Pair<int *, int> > render_mode_values;
+ Map<StringName, bool *> render_mode_flags;
+ Map<StringName, bool *> usage_flag_pointers;
- Map<StringName,ShaderLanguage::ShaderNode::Uniform> *uniforms;
+ Map<StringName, ShaderLanguage::ShaderNode::Uniform> *uniforms;
};
struct GeneratedCode {
@@ -62,23 +62,20 @@ public:
bool uses_fragment_time;
bool uses_vertex_time;
-
};
private:
-
ShaderLanguage parser;
struct DefaultIdentifierActions {
- Map<StringName,String> renames;
- Map<StringName,String> render_mode_defines;
- Map<StringName,String> usage_defines;
+ Map<StringName, String> renames;
+ Map<StringName, String> render_mode_defines;
+ Map<StringName, String> usage_defines;
};
- void _dump_function_deps(ShaderLanguage::ShaderNode *p_node, const StringName& p_for_func, const Map<StringName, String> &p_func_code, String& r_to_add,Set<StringName> &added);
- String _dump_node_code(ShaderLanguage::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions& p_actions, const DefaultIdentifierActions& p_default_actions);
-
+ void _dump_function_deps(ShaderLanguage::ShaderNode *p_node, const StringName &p_for_func, const Map<StringName, String> &p_func_code, String &r_to_add, Set<StringName> &added);
+ String _dump_node_code(ShaderLanguage::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions);
StringName current_func_name;
StringName vertex_name;
@@ -90,14 +87,10 @@ private:
Set<StringName> used_rmode_defines;
Set<StringName> internal_functions;
-
DefaultIdentifierActions actions[VS::SHADER_MAX];
public:
-
-
- Error compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String& p_path, GeneratedCode& r_gen_code);
-
+ Error compile(VS::ShaderMode p_mode, const String &p_code, IdentifierActions *p_actions, const String &p_path, GeneratedCode &r_gen_code);
ShaderCompilerGLES3();
};
diff --git a/drivers/gles3/shader_gles3.cpp b/drivers/gles3/shader_gles3.cpp
index a148d68a9..3894f2429 100644
--- a/drivers/gles3/shader_gles3.cpp
+++ b/drivers/gles3/shader_gles3.cpp
@@ -28,29 +28,26 @@
/*************************************************************************/
#include "shader_gles3.h"
-
#include "print_string.h"
//#define DEBUG_OPENGL
#ifdef DEBUG_OPENGL
-#define DEBUG_TEST_ERROR(m_section)\
-{\
- uint32_t err = glGetError();\
- if (err) {\
- print_line("OpenGL Error #"+itos(err)+" at: "+m_section);\
- }\
-}
+#define DEBUG_TEST_ERROR(m_section) \
+ { \
+ uint32_t err = glGetError(); \
+ if (err) { \
+ print_line("OpenGL Error #" + itos(err) + " at: " + m_section); \
+ } \
+ }
#else
#define DEBUG_TEST_ERROR(m_section)
#endif
-ShaderGLES3 *ShaderGLES3::active=NULL;
-
-
+ShaderGLES3 *ShaderGLES3::active = NULL;
//#define DEBUG_SHADER
@@ -64,7 +61,6 @@ ShaderGLES3 *ShaderGLES3::active=NULL;
#endif
-
void ShaderGLES3::bind_uniforms() {
if (!uniforms_dirty) {
@@ -72,34 +68,33 @@ void ShaderGLES3::bind_uniforms() {
};
// upload default uniforms
- const Map<uint32_t,Variant>::Element *E =uniform_defaults.front();
+ const Map<uint32_t, Variant>::Element *E = uniform_defaults.front();
- while(E) {
- int idx=E->key();
- int location=version->uniform_location[idx];
+ while (E) {
+ int idx = E->key();
+ int location = version->uniform_location[idx];
- if (location<0) {
- E=E->next();
+ if (location < 0) {
+ E = E->next();
continue;
-
}
- const Variant &v=E->value();
+ const Variant &v = E->value();
_set_uniform_variant(location, v);
//print_line("uniform "+itos(location)+" value "+v+ " type "+Variant::get_type_name(v.get_type()));
- E=E->next();
+ E = E->next();
};
- const Map<uint32_t,CameraMatrix>::Element* C = uniform_cameras.front();
+ const Map<uint32_t, CameraMatrix>::Element *C = uniform_cameras.front();
while (C) {
int location = version->uniform_location[C->key()];
- if (location<0) {
- C=C->next();
+ if (location < 0) {
+ C = C->next();
continue;
}
- glUniformMatrix4fv(location,1,false,&(C->get().matrix[0][0]));
+ glUniformMatrix4fv(location, 1, false, &(C->get().matrix[0][0]));
C = C->next();
};
@@ -114,24 +109,24 @@ GLint ShaderGLES3::get_uniform_location(int p_idx) const {
};
bool ShaderGLES3::bind() {
-
- if (active!=this || !version || new_conditional_version.key!=conditional_version.key) {
- conditional_version=new_conditional_version;
+
+ if (active != this || !version || new_conditional_version.key != conditional_version.key) {
+ conditional_version = new_conditional_version;
version = get_current_version();
} else {
return false;
}
-
- ERR_FAIL_COND_V(!version,false);
- glUseProgram( version->id );
+ ERR_FAIL_COND_V(!version, false);
+
+ glUseProgram(version->id);
DEBUG_TEST_ERROR("Use Program");
- active=this;
+ active = this;
uniforms_dirty = true;
-/*
+ /*
* why on earth is this code here?
for (int i=0;i<texunit_pair_count;i++) {
@@ -145,152 +140,133 @@ bool ShaderGLES3::bind() {
void ShaderGLES3::unbind() {
- version=NULL;
+ version = NULL;
glUseProgram(0);
uniforms_dirty = true;
- active=NULL;
+ active = NULL;
}
+static void _display_error_with_code(const String &p_error, const Vector<const char *> &p_code) {
-static void _display_error_with_code(const String& p_error,const Vector<const char*>& p_code) {
-
-
- int line=1;
+ int line = 1;
String total_code;
- for(int i=0;i<p_code.size();i++) {
- total_code+=String(p_code[i]);
+ for (int i = 0; i < p_code.size(); i++) {
+ total_code += String(p_code[i]);
}
Vector<String> lines = String(total_code).split("\n");
- for(int j=0;j<lines.size();j++) {
+ for (int j = 0; j < lines.size(); j++) {
- print_line(itos(line)+": "+lines[j]);
+ print_line(itos(line) + ": " + lines[j]);
line++;
}
ERR_PRINTS(p_error);
-
}
-ShaderGLES3::Version* ShaderGLES3::get_current_version() {
+ShaderGLES3::Version *ShaderGLES3::get_current_version() {
- Version *_v=version_map.getptr(conditional_version);
+ Version *_v = version_map.getptr(conditional_version);
if (_v) {
- if (conditional_version.code_version!=0) {
- CustomCode *cc=custom_code_map.getptr(conditional_version.code_version);
- ERR_FAIL_COND_V(!cc,_v);
- if (cc->version==_v->code_version)
+ if (conditional_version.code_version != 0) {
+ CustomCode *cc = custom_code_map.getptr(conditional_version.code_version);
+ ERR_FAIL_COND_V(!cc, _v);
+ if (cc->version == _v->code_version)
return _v;
} else {
return _v;
}
-
}
-
-
if (!_v)
- version_map[conditional_version]=Version();
-
+ version_map[conditional_version] = Version();
Version &v = version_map[conditional_version];
if (!_v) {
- v.uniform_location = memnew_arr( GLint, uniform_count );
+ v.uniform_location = memnew_arr(GLint, uniform_count);
} else {
if (v.ok) {
//bye bye shaders
- glDeleteShader( v.vert_id );
- glDeleteShader( v.frag_id );
- glDeleteProgram( v.id );
- v.id=0;
+ glDeleteShader(v.vert_id);
+ glDeleteShader(v.frag_id);
+ glDeleteProgram(v.id);
+ v.id = 0;
}
-
}
-
-
- v.ok=false;
+ v.ok = false;
/* SETUP CONDITIONALS */
-
- Vector<const char*> strings;
+
+ Vector<const char *> strings;
#ifdef GLES_OVER_GL
strings.push_back("#version 330\n");
#else
strings.push_back("#version 300 es\n");
#endif
+ int define_line_ofs = 1;
-
- int define_line_ofs=1;
-
- for(int i=0;i<custom_defines.size();i++) {
+ for (int i = 0; i < custom_defines.size(); i++) {
strings.push_back(custom_defines[i].get_data());
define_line_ofs++;
}
- for(int j=0;j<conditional_count;j++) {
-
- bool enable=((1<<j)&conditional_version.version);
- strings.push_back(enable?conditional_defines[j]:"");
+ for (int j = 0; j < conditional_count; j++) {
+
+ bool enable = ((1 << j) & conditional_version.version);
+ strings.push_back(enable ? conditional_defines[j] : "");
if (enable)
define_line_ofs++;
if (enable) {
DEBUG_PRINT(conditional_defines[j]);
}
-
}
-
-
//keep them around during the function
CharString code_string;
CharString code_string2;
CharString code_globals;
CharString material_string;
-
//print_line("code version? "+itos(conditional_version.code_version));
- CustomCode *cc=NULL;
+ CustomCode *cc = NULL;
- if ( conditional_version.code_version>0 ) {
+ if (conditional_version.code_version > 0) {
//do custom code related stuff
- ERR_FAIL_COND_V( !custom_code_map.has( conditional_version.code_version ), NULL );
- cc=&custom_code_map[conditional_version.code_version];
- v.code_version=cc->version;
- define_line_ofs+=2;
-
+ ERR_FAIL_COND_V(!custom_code_map.has(conditional_version.code_version), NULL);
+ cc = &custom_code_map[conditional_version.code_version];
+ v.code_version = cc->version;
+ define_line_ofs += 2;
}
-
/* CREATE PROGRAM */
-
+
v.id = glCreateProgram();
-
- ERR_FAIL_COND_V(v.id==0, NULL);
-
- /* VERTEX SHADER */
+ ERR_FAIL_COND_V(v.id == 0, NULL);
+
+ /* VERTEX SHADER */
if (cc) {
- for(int i=0;i<cc->custom_defines.size();i++) {
+ for (int i = 0; i < cc->custom_defines.size(); i++) {
strings.push_back(cc->custom_defines[i].get_data());
- DEBUG_PRINT("CD #"+itos(i)+": "+String(cc->custom_defines[i]));
+ DEBUG_PRINT("CD #" + itos(i) + ": " + String(cc->custom_defines[i]));
}
}
- int strings_base_size=strings.size();
+ int strings_base_size = strings.size();
//vertex precision is high
strings.push_back("precision highp float;\n");
@@ -311,83 +287,78 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
}
#endif
-
strings.push_back(vertex_code0.get_data());
if (cc) {
- code_globals=cc->vertex_globals.ascii();
+ code_globals = cc->vertex_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(vertex_code1.get_data());
if (cc) {
- material_string=cc->uniforms.ascii();
+ material_string = cc->uniforms.ascii();
strings.push_back(material_string.get_data());
}
strings.push_back(vertex_code2.get_data());
if (cc) {
- code_string=cc->vertex.ascii();
+ code_string = cc->vertex.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(vertex_code3.get_data());
#ifdef DEBUG_SHADER
- DEBUG_PRINT("\nVertex Code:\n\n"+String(code_string.get_data()));
- for(int i=0;i<strings.size();i++) {
+ DEBUG_PRINT("\nVertex Code:\n\n" + String(code_string.get_data()));
+ for (int i = 0; i < strings.size(); i++) {
//print_line("vert strings "+itos(i)+":"+String(strings[i]));
}
#endif
-
v.vert_id = glCreateShader(GL_VERTEX_SHADER);
- glShaderSource(v.vert_id,strings.size(),&strings[0],NULL);
+ glShaderSource(v.vert_id, strings.size(), &strings[0], NULL);
glCompileShader(v.vert_id);
-
+
GLint status;
-
- glGetShaderiv(v.vert_id,GL_COMPILE_STATUS,&status);
- if (status==GL_FALSE) {
- // error compiling
+
+ glGetShaderiv(v.vert_id, GL_COMPILE_STATUS, &status);
+ if (status == GL_FALSE) {
+ // error compiling
GLsizei iloglen;
- glGetShaderiv(v.vert_id,GL_INFO_LOG_LENGTH,&iloglen);
-
- if (iloglen<0) {
-
+ glGetShaderiv(v.vert_id, GL_INFO_LOG_LENGTH, &iloglen);
+
+ if (iloglen < 0) {
+
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
-
+ glDeleteProgram(v.id);
+ v.id = 0;
+
ERR_PRINT("NO LOG, WTF");
} else {
- if (iloglen==0) {
+ if (iloglen == 0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
-
- char *ilogmem = (char*)memalloc(iloglen+1);
- ilogmem[iloglen]=0;
- glGetShaderInfoLog(v.vert_id, iloglen, &iloglen, ilogmem);
-
- String err_string=get_shader_name()+": Vertex Program Compilation Failed:\n";
-
- err_string+=ilogmem;
- _display_error_with_code(err_string,strings);
+ char *ilogmem = (char *)memalloc(iloglen + 1);
+ ilogmem[iloglen] = 0;
+ glGetShaderInfoLog(v.vert_id, iloglen, &iloglen, ilogmem);
+
+ String err_string = get_shader_name() + ": Vertex Program Compilation Failed:\n";
+
+ err_string += ilogmem;
+ _display_error_with_code(err_string, strings);
memfree(ilogmem);
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
-
+ glDeleteProgram(v.id);
+ v.id = 0;
}
-
- ERR_FAIL_V(NULL);
- }
+ ERR_FAIL_V(NULL);
+ }
/* FRAGMENT SHADER */
@@ -411,317 +382,308 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
}
#endif
-
strings.push_back(fragment_code0.get_data());
if (cc) {
- code_globals=cc->fragment_globals.ascii();
+ code_globals = cc->fragment_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(fragment_code1.get_data());
if (cc) {
- material_string=cc->uniforms.ascii();
+ material_string = cc->uniforms.ascii();
strings.push_back(material_string.get_data());
}
strings.push_back(fragment_code2.get_data());
if (cc) {
- code_string=cc->fragment.ascii();
+ code_string = cc->fragment.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(fragment_code3.get_data());
if (cc) {
- code_string2=cc->light.ascii();
+ code_string2 = cc->light.ascii();
strings.push_back(code_string2.get_data());
}
strings.push_back(fragment_code4.get_data());
#ifdef DEBUG_SHADER
- DEBUG_PRINT("\nFragment Code:\n\n"+String(code_string.get_data()));
- for(int i=0;i<strings.size();i++) {
+ DEBUG_PRINT("\nFragment Code:\n\n" + String(code_string.get_data()));
+ for (int i = 0; i < strings.size(); i++) {
//print_line("frag strings "+itos(i)+":"+String(strings[i]));
}
#endif
v.frag_id = glCreateShader(GL_FRAGMENT_SHADER);
- glShaderSource(v.frag_id,strings.size(),&strings[0],NULL);
+ glShaderSource(v.frag_id, strings.size(), &strings[0], NULL);
glCompileShader(v.frag_id);
-
- glGetShaderiv(v.frag_id,GL_COMPILE_STATUS,&status);
- if (status==GL_FALSE) {
- // error compiling
+
+ glGetShaderiv(v.frag_id, GL_COMPILE_STATUS, &status);
+ if (status == GL_FALSE) {
+ // error compiling
GLsizei iloglen;
- glGetShaderiv(v.frag_id,GL_INFO_LOG_LENGTH,&iloglen);
-
- if (iloglen<0) {
+ glGetShaderiv(v.frag_id, GL_INFO_LOG_LENGTH, &iloglen);
+
+ if (iloglen < 0) {
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
+ glDeleteProgram(v.id);
+ v.id = 0;
ERR_PRINT("NO LOG, WTF");
} else {
-
- if (iloglen==0) {
+
+ if (iloglen == 0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
- char *ilogmem = (char*)memalloc(iloglen+1);
- ilogmem[iloglen]=0;
- glGetShaderInfoLog(v.frag_id, iloglen, &iloglen, ilogmem);
-
- String err_string=get_shader_name()+": Fragment Program Compilation Failed:\n";
-
- err_string+=ilogmem;
- _display_error_with_code(err_string,strings);
+ char *ilogmem = (char *)memalloc(iloglen + 1);
+ ilogmem[iloglen] = 0;
+ glGetShaderInfoLog(v.frag_id, iloglen, &iloglen, ilogmem);
+
+ String err_string = get_shader_name() + ": Fragment Program Compilation Failed:\n";
+
+ err_string += ilogmem;
+ _display_error_with_code(err_string, strings);
ERR_PRINT(err_string.ascii().get_data());
memfree(ilogmem);
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
-
+ glDeleteProgram(v.id);
+ v.id = 0;
}
-
- ERR_FAIL_V( NULL );
- }
- glAttachShader(v.id,v.frag_id);
- glAttachShader(v.id,v.vert_id);
+ ERR_FAIL_V(NULL);
+ }
+
+ glAttachShader(v.id, v.frag_id);
+ glAttachShader(v.id, v.vert_id);
// bind attributes before linking
- for (int i=0;i<attribute_pair_count;i++) {
+ for (int i = 0; i < attribute_pair_count; i++) {
- glBindAttribLocation(v.id, attribute_pairs[i].index, attribute_pairs[i].name );
+ glBindAttribLocation(v.id, attribute_pairs[i].index, attribute_pairs[i].name);
}
//if feedback exists, set it up
if (feedback_count) {
- Vector<const char*> feedback;
- for(int i=0;i<feedback_count;i++) {
+ Vector<const char *> feedback;
+ for (int i = 0; i < feedback_count; i++) {
- if (feedbacks[i].conditional==-1 || (1<<feedbacks[i].conditional)&conditional_version.version) {
+ if (feedbacks[i].conditional == -1 || (1 << feedbacks[i].conditional) & conditional_version.version) {
//conditional for this feedback is enabled
- print_line("tf varying: "+itos(feedback.size())+" "+String(feedbacks[i].name));
+ print_line("tf varying: " + itos(feedback.size()) + " " + String(feedbacks[i].name));
feedback.push_back(feedbacks[i].name);
}
}
if (feedback.size()) {
- glTransformFeedbackVaryings(v.id,feedback.size(),feedback.ptr(),GL_INTERLEAVED_ATTRIBS );
+ glTransformFeedbackVaryings(v.id, feedback.size(), feedback.ptr(), GL_INTERLEAVED_ATTRIBS);
}
-
}
glLinkProgram(v.id);
-
+
glGetProgramiv(v.id, GL_LINK_STATUS, &status);
-
- if (status==GL_FALSE) {
- // error linking
+
+ if (status == GL_FALSE) {
+ // error linking
GLsizei iloglen;
- glGetProgramiv(v.id,GL_INFO_LOG_LENGTH,&iloglen);
-
- if (iloglen<0) {
-
+ glGetProgramiv(v.id, GL_INFO_LOG_LENGTH, &iloglen);
+
+ if (iloglen < 0) {
+
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
- ERR_FAIL_COND_V(iloglen<=0, NULL);
+ glDeleteProgram(v.id);
+ v.id = 0;
+ ERR_FAIL_COND_V(iloglen <= 0, NULL);
}
- if (iloglen==0) {
+ if (iloglen == 0) {
iloglen = 4096; //buggy driver (Adreno 220+....)
}
-
- char *ilogmem = (char*)Memory::alloc_static(iloglen+1);
- ilogmem[iloglen]=0;
- glGetProgramInfoLog(v.id, iloglen, &iloglen, ilogmem);
-
- String err_string=get_shader_name()+": Program LINK FAILED:\n";
-
- err_string+=ilogmem;
- _display_error_with_code(err_string,strings);
+ char *ilogmem = (char *)Memory::alloc_static(iloglen + 1);
+ ilogmem[iloglen] = 0;
+ glGetProgramInfoLog(v.id, iloglen, &iloglen, ilogmem);
+
+ String err_string = get_shader_name() + ": Program LINK FAILED:\n";
+
+ err_string += ilogmem;
+ _display_error_with_code(err_string, strings);
ERR_PRINT(err_string.ascii().get_data());
Memory::free_static(ilogmem);
glDeleteShader(v.frag_id);
glDeleteShader(v.vert_id);
- glDeleteProgram( v.id );
- v.id=0;
-
+ glDeleteProgram(v.id);
+ v.id = 0;
+
ERR_FAIL_V(NULL);
}
-
- /* UNIFORMS */
-
- glUseProgram(v.id);
+ /* UNIFORMS */
+
+ glUseProgram(v.id);
//print_line("uniforms: ");
- for(int j=0;j<uniform_count;j++) {
-
-
- v.uniform_location[j]=glGetUniformLocation(v.id,uniform_names[j]);
+ for (int j = 0; j < uniform_count; j++) {
+
+ v.uniform_location[j] = glGetUniformLocation(v.id, uniform_names[j]);
//print_line("uniform "+String(uniform_names[j])+" location "+itos(v.uniform_location[j]));
}
-
+
// set texture uniforms
- for (int i=0;i<texunit_pair_count;i++) {
+ for (int i = 0; i < texunit_pair_count; i++) {
- GLint loc = glGetUniformLocation(v.id,texunit_pairs[i].name);
- if (loc>=0) {
- if (texunit_pairs[i].index<0) {
- glUniform1i(loc,max_image_units+texunit_pairs[i].index); //negative, goes down
+ GLint loc = glGetUniformLocation(v.id, texunit_pairs[i].name);
+ if (loc >= 0) {
+ if (texunit_pairs[i].index < 0) {
+ glUniform1i(loc, max_image_units + texunit_pairs[i].index); //negative, goes down
} else {
- glUniform1i(loc,texunit_pairs[i].index);
+ glUniform1i(loc, texunit_pairs[i].index);
}
}
}
// assign uniform block bind points
- for (int i=0;i<ubo_count;i++) {
+ for (int i = 0; i < ubo_count; i++) {
- GLint loc = glGetUniformBlockIndex(v.id,ubo_pairs[i].name);
- if (loc>=0)
- glUniformBlockBinding(v.id,loc,ubo_pairs[i].index);
+ GLint loc = glGetUniformBlockIndex(v.id, ubo_pairs[i].name);
+ if (loc >= 0)
+ glUniformBlockBinding(v.id, loc, ubo_pairs[i].index);
}
- if ( cc ) {
+ if (cc) {
v.texture_uniform_locations.resize(cc->texture_uniforms.size());
- for(int i=0;i<cc->texture_uniforms.size();i++) {
+ for (int i = 0; i < cc->texture_uniforms.size(); i++) {
- v.texture_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->texture_uniforms[i]).ascii().get_data());
- glUniform1i(v.texture_uniform_locations[i],i+base_material_tex_index);
+ v.texture_uniform_locations[i] = glGetUniformLocation(v.id, String(cc->texture_uniforms[i]).ascii().get_data());
+ glUniform1i(v.texture_uniform_locations[i], i + base_material_tex_index);
}
}
glUseProgram(0);
-
- v.ok=true;
+ v.ok = true;
return &v;
}
-GLint ShaderGLES3::get_uniform_location(const String& p_name) const {
+GLint ShaderGLES3::get_uniform_location(const String &p_name) const {
- ERR_FAIL_COND_V(!version,-1);
- return glGetUniformLocation(version->id,p_name.ascii().get_data());
+ ERR_FAIL_COND_V(!version, -1);
+ return glGetUniformLocation(version->id, p_name.ascii().get_data());
}
-
-void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_count,const char** p_uniform_names,int p_uniform_count, const AttributePair* p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs, int p_ubo_pair_count, const Feedback* p_feedback, int p_feedback_count,const char*p_vertex_code, const char *p_fragment_code,int p_vertex_code_start,int p_fragment_code_start) {
+void ShaderGLES3::setup(const char **p_conditional_defines, int p_conditional_count, const char **p_uniform_names, int p_uniform_count, const AttributePair *p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs, int p_ubo_pair_count, const Feedback *p_feedback, int p_feedback_count, const char *p_vertex_code, const char *p_fragment_code, int p_vertex_code_start, int p_fragment_code_start) {
ERR_FAIL_COND(version);
- conditional_version.key=0;
- new_conditional_version.key=0;
- uniform_count=p_uniform_count;
- conditional_count=p_conditional_count;
- conditional_defines=p_conditional_defines;
- uniform_names=p_uniform_names;
- vertex_code=p_vertex_code;
- fragment_code=p_fragment_code;
- texunit_pairs=p_texunit_pairs;
- texunit_pair_count=p_texunit_pair_count;
- vertex_code_start=p_vertex_code_start;
- fragment_code_start=p_fragment_code_start;
- attribute_pairs=p_attribute_pairs;
- attribute_pair_count=p_attribute_count;
- ubo_pairs=p_ubo_pairs;
- ubo_count=p_ubo_pair_count;
- feedbacks=p_feedback;
- feedback_count=p_feedback_count;
+ conditional_version.key = 0;
+ new_conditional_version.key = 0;
+ uniform_count = p_uniform_count;
+ conditional_count = p_conditional_count;
+ conditional_defines = p_conditional_defines;
+ uniform_names = p_uniform_names;
+ vertex_code = p_vertex_code;
+ fragment_code = p_fragment_code;
+ texunit_pairs = p_texunit_pairs;
+ texunit_pair_count = p_texunit_pair_count;
+ vertex_code_start = p_vertex_code_start;
+ fragment_code_start = p_fragment_code_start;
+ attribute_pairs = p_attribute_pairs;
+ attribute_pair_count = p_attribute_count;
+ ubo_pairs = p_ubo_pairs;
+ ubo_count = p_ubo_pair_count;
+ feedbacks = p_feedback;
+ feedback_count = p_feedback_count;
//split vertex and shader code (thank you, retarded shader compiler programmers from you know what company).
{
- String globals_tag="\nVERTEX_SHADER_GLOBALS";
- String material_tag="\nMATERIAL_UNIFORMS";
- String code_tag="\nVERTEX_SHADER_CODE";
- String code = vertex_code;
+ String globals_tag = "\nVERTEX_SHADER_GLOBALS";
+ String material_tag = "\nMATERIAL_UNIFORMS";
+ String code_tag = "\nVERTEX_SHADER_CODE";
+ String code = vertex_code;
int cpos = code.find(globals_tag);
- if (cpos==-1) {
- vertex_code0=code.ascii();
+ if (cpos == -1) {
+ vertex_code0 = code.ascii();
} else {
- vertex_code0=code.substr(0,cpos).ascii();
- code = code.substr(cpos+globals_tag.length(),code.length());
+ vertex_code0 = code.substr(0, cpos).ascii();
+ code = code.substr(cpos + globals_tag.length(), code.length());
cpos = code.find(material_tag);
- if (cpos==-1) {
- vertex_code1=code.ascii();
+ if (cpos == -1) {
+ vertex_code1 = code.ascii();
} else {
- vertex_code1=code.substr(0,cpos).ascii();
- String code2 = code.substr(cpos+material_tag.length(),code.length());
+ vertex_code1 = code.substr(0, cpos).ascii();
+ String code2 = code.substr(cpos + material_tag.length(), code.length());
cpos = code2.find(code_tag);
- if (cpos==-1) {
- vertex_code2=code2.ascii();
+ if (cpos == -1) {
+ vertex_code2 = code2.ascii();
} else {
- vertex_code2=code2.substr(0,cpos).ascii();
- vertex_code3 = code2.substr(cpos+code_tag.length(),code2.length()).ascii();
+ vertex_code2 = code2.substr(0, cpos).ascii();
+ vertex_code3 = code2.substr(cpos + code_tag.length(), code2.length()).ascii();
}
-
}
}
}
{
- String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
- String material_tag="\nMATERIAL_UNIFORMS";
- String code_tag="\nFRAGMENT_SHADER_CODE";
- String light_code_tag="\nLIGHT_SHADER_CODE";
- String code = fragment_code;
+ String globals_tag = "\nFRAGMENT_SHADER_GLOBALS";
+ String material_tag = "\nMATERIAL_UNIFORMS";
+ String code_tag = "\nFRAGMENT_SHADER_CODE";
+ String light_code_tag = "\nLIGHT_SHADER_CODE";
+ String code = fragment_code;
int cpos = code.find(globals_tag);
- if (cpos==-1) {
- fragment_code0=code.ascii();
+ if (cpos == -1) {
+ fragment_code0 = code.ascii();
} else {
- fragment_code0=code.substr(0,cpos).ascii();
+ fragment_code0 = code.substr(0, cpos).ascii();
//print_line("CODE0:\n"+String(fragment_code0.get_data()));
- code = code.substr(cpos+globals_tag.length(),code.length());
+ code = code.substr(cpos + globals_tag.length(), code.length());
cpos = code.find(material_tag);
- if (cpos==-1) {
- fragment_code1=code.ascii();
+ if (cpos == -1) {
+ fragment_code1 = code.ascii();
} else {
- fragment_code1=code.substr(0,cpos).ascii();
+ fragment_code1 = code.substr(0, cpos).ascii();
//print_line("CODE1:\n"+String(fragment_code1.get_data()));
- String code2 = code.substr(cpos+material_tag.length(),code.length());
+ String code2 = code.substr(cpos + material_tag.length(), code.length());
cpos = code2.find(code_tag);
- if (cpos==-1) {
- fragment_code2=code2.ascii();
+ if (cpos == -1) {
+ fragment_code2 = code2.ascii();
} else {
- fragment_code2=code2.substr(0,cpos).ascii();
+ 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());
+ String code3 = code2.substr(cpos + code_tag.length(), code2.length());
cpos = code3.find(light_code_tag);
- if (cpos==-1) {
- fragment_code3=code3.ascii();
+ if (cpos == -1) {
+ fragment_code3 = code3.ascii();
} else {
- fragment_code3=code3.substr(0,cpos).ascii();
+ 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();
+ fragment_code4 = code3.substr(cpos + light_code_tag.length(), code3.length()).ascii();
//print_line("CODE4:\n"+String(fragment_code4.get_data()));
}
}
@@ -729,111 +691,99 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
}
}
- glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&max_image_units);
-
+ glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_image_units);
}
void ShaderGLES3::finish() {
-
- const VersionKey *V=NULL;
- while((V=version_map.next(V))) {
-
- Version &v=version_map[*V];
- glDeleteShader( v.vert_id );
- glDeleteShader( v.frag_id );
- glDeleteProgram( v.id );
- memdelete_arr( v.uniform_location );
+ const VersionKey *V = NULL;
+ while ((V = version_map.next(V))) {
+
+ Version &v = version_map[*V];
+ glDeleteShader(v.vert_id);
+ glDeleteShader(v.frag_id);
+ glDeleteProgram(v.id);
+ memdelete_arr(v.uniform_location);
}
-
}
-
void ShaderGLES3::clear_caches() {
- const VersionKey *V=NULL;
- while((V=version_map.next(V))) {
-
- Version &v=version_map[*V];
- glDeleteShader( v.vert_id );
- glDeleteShader( v.frag_id );
- glDeleteProgram( v.id );
- memdelete_arr( v.uniform_location );
+ const VersionKey *V = NULL;
+ while ((V = version_map.next(V))) {
+
+ Version &v = version_map[*V];
+ glDeleteShader(v.vert_id);
+ glDeleteShader(v.frag_id);
+ glDeleteProgram(v.id);
+ memdelete_arr(v.uniform_location);
}
version_map.clear();
custom_code_map.clear();
- version=NULL;
- last_custom_code=1;
+ version = NULL;
+ last_custom_code = 1;
uniforms_dirty = true;
-
}
uint32_t ShaderGLES3::create_custom_shader() {
- custom_code_map[last_custom_code]=CustomCode();
- custom_code_map[last_custom_code].version=1;
+ custom_code_map[last_custom_code] = CustomCode();
+ custom_code_map[last_custom_code].version = 1;
return last_custom_code++;
}
-void ShaderGLES3::set_custom_shader_code(uint32_t p_code_id, const String& p_vertex, const String& p_vertex_globals, const String& p_fragment, const String& p_light, const String& p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines) {
+void ShaderGLES3::set_custom_shader_code(uint32_t p_code_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_light, const String &p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines) {
ERR_FAIL_COND(!custom_code_map.has(p_code_id));
- CustomCode *cc=&custom_code_map[p_code_id];
-
+ CustomCode *cc = &custom_code_map[p_code_id];
- cc->vertex=p_vertex;
- cc->vertex_globals=p_vertex_globals;
- cc->fragment=p_fragment;
- cc->fragment_globals=p_fragment_globals;
- cc->light=p_light;
- cc->texture_uniforms=p_texture_uniforms;
- cc->uniforms=p_uniforms;
- cc->custom_defines=p_custom_defines;
+ cc->vertex = p_vertex;
+ cc->vertex_globals = p_vertex_globals;
+ cc->fragment = p_fragment;
+ cc->fragment_globals = p_fragment_globals;
+ cc->light = p_light;
+ cc->texture_uniforms = p_texture_uniforms;
+ cc->uniforms = p_uniforms;
+ cc->custom_defines = p_custom_defines;
cc->version++;
}
void ShaderGLES3::set_custom_shader(uint32_t p_code_id) {
- new_conditional_version.code_version=p_code_id;
+ new_conditional_version.code_version = p_code_id;
}
void ShaderGLES3::free_custom_shader(uint32_t p_code_id) {
- /* if (! custom_code_map.has( p_code_id )) {
+ /* if (! custom_code_map.has( p_code_id )) {
print_line("no code id "+itos(p_code_id));
} else {
print_line("freed code id "+itos(p_code_id));
}*/
- ERR_FAIL_COND(! custom_code_map.has( p_code_id ));
- if (conditional_version.code_version==p_code_id)
- conditional_version.code_version=0; //bye
+ ERR_FAIL_COND(!custom_code_map.has(p_code_id));
+ if (conditional_version.code_version == p_code_id)
+ conditional_version.code_version = 0; //bye
custom_code_map.erase(p_code_id);
-
}
void ShaderGLES3::set_base_material_tex_index(int p_idx) {
- base_material_tex_index=p_idx;
+ base_material_tex_index = p_idx;
}
ShaderGLES3::ShaderGLES3() {
- version=NULL;
- last_custom_code=1;
+ version = NULL;
+ last_custom_code = 1;
uniforms_dirty = true;
- base_material_tex_index=0;
-
+ base_material_tex_index = 0;
}
-
ShaderGLES3::~ShaderGLES3() {
-
+
finish();
}
-
-
-
diff --git a/drivers/gles3/shader_gles3.h b/drivers/gles3/shader_gles3.h
index 464f359d5..6f5ccc912 100644
--- a/drivers/gles3/shader_gles3.h
+++ b/drivers/gles3/shader_gles3.h
@@ -38,19 +38,17 @@
#include GLES3_INCLUDE_H
#endif
+#include "camera_matrix.h"
#include "hash_map.h"
#include "map.h"
#include "variant.h"
-#include "camera_matrix.h"
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
-
class ShaderGLES3 {
-protected:
-
+protected:
struct Enum {
uint64_t mask;
@@ -71,7 +69,7 @@ protected:
};
struct UniformPair {
- const char* name;
+ const char *name;
Variant::Type type_hint;
};
@@ -94,8 +92,8 @@ protected:
};
bool uniforms_dirty;
-private:
+private:
//@TODO Optimize to a fixed set of shader pools and use a LRU
int uniform_count;
int texunit_pair_count;
@@ -117,22 +115,24 @@ private:
uint32_t version;
Vector<StringName> texture_uniforms;
Vector<CharString> custom_defines;
-
};
-
struct Version {
-
+
GLuint id;
GLuint vert_id;
- GLuint frag_id;
+ GLuint frag_id;
GLint *uniform_location;
Vector<GLint> texture_uniform_locations;
uint32_t code_version;
bool ok;
- Version() { code_version=0; ok=false; uniform_location=NULL; }
+ Version() {
+ code_version = 0;
+ ok = false;
+ uniform_location = NULL;
+ }
};
-
+
Version *version;
union VersionKey {
@@ -142,36 +142,34 @@ private:
uint32_t code_version;
};
uint64_t key;
- bool operator==(const VersionKey& p_key) const { return key==p_key.key; }
- bool operator<(const VersionKey& p_key) const { return key<p_key.key; }
-
+ bool operator==(const VersionKey &p_key) const { return key == p_key.key; }
+ bool operator<(const VersionKey &p_key) const { return key < p_key.key; }
};
struct VersionKeyHash {
- static _FORCE_INLINE_ uint32_t hash( const VersionKey& p_key) { return HashMapHasherDefault::hash(p_key.key); };
+ static _FORCE_INLINE_ uint32_t hash(const VersionKey &p_key) { return HashMapHasherDefault::hash(p_key.key); };
};
//this should use a way more cachefriendly version..
- HashMap<VersionKey,Version,VersionKeyHash> version_map;
+ HashMap<VersionKey, Version, VersionKeyHash> version_map;
- HashMap<uint32_t,CustomCode> custom_code_map;
+ HashMap<uint32_t, CustomCode> custom_code_map;
uint32_t last_custom_code;
-
-
+
VersionKey conditional_version;
VersionKey new_conditional_version;
-
- virtual String get_shader_name() const=0;
-
- const char** conditional_defines;
- const char** uniform_names;
+
+ virtual String get_shader_name() const = 0;
+
+ const char **conditional_defines;
+ const char **uniform_names;
const AttributePair *attribute_pairs;
const TexUnitPair *texunit_pairs;
const UBOPair *ubo_pairs;
const Feedback *feedbacks;
- const char* vertex_code;
- const char* fragment_code;
+ const char *vertex_code;
+ const char *fragment_code;
CharString fragment_code0;
CharString fragment_code1;
CharString fragment_code2;
@@ -187,213 +185,204 @@ private:
int base_material_tex_index;
- Version * get_current_version();
-
+ Version *get_current_version();
+
static ShaderGLES3 *active;
int max_image_units;
- _FORCE_INLINE_ void _set_uniform_variant(GLint p_uniform,const Variant& p_value) {
+ _FORCE_INLINE_ void _set_uniform_variant(GLint p_uniform, const Variant &p_value) {
- if (p_uniform<0)
+ if (p_uniform < 0)
return; // do none
- switch(p_value.get_type()) {
-
- case Variant::BOOL:
- case Variant::INT: {
+ switch (p_value.get_type()) {
- int val=p_value;
- glUniform1i( p_uniform, val );
- } break;
- case Variant::REAL: {
+ case Variant::BOOL:
+ case Variant::INT: {
- real_t val=p_value;
- glUniform1f( p_uniform, val );
- } break;
- case Variant::COLOR: {
+ int val = p_value;
+ glUniform1i(p_uniform, val);
+ } break;
+ case Variant::REAL: {
- Color val=p_value;
- glUniform4f( p_uniform, val.r, val.g,val.b,val.a );
- } break;
- case Variant::VECTOR2: {
+ real_t val = p_value;
+ glUniform1f(p_uniform, val);
+ } break;
+ case Variant::COLOR: {
- Vector2 val=p_value;
- glUniform2f( p_uniform, val.x,val.y );
- } break;
- case Variant::VECTOR3: {
+ Color val = p_value;
+ glUniform4f(p_uniform, val.r, val.g, val.b, val.a);
+ } break;
+ case Variant::VECTOR2: {
- Vector3 val=p_value;
- glUniform3f( p_uniform, val.x,val.y,val.z );
- } break;
- case Variant::PLANE: {
+ Vector2 val = p_value;
+ glUniform2f(p_uniform, val.x, val.y);
+ } break;
+ case Variant::VECTOR3: {
- Plane val=p_value;
- glUniform4f( p_uniform, val.normal.x,val.normal.y,val.normal.z,val.d );
- } break;
- case Variant::QUAT: {
+ Vector3 val = p_value;
+ glUniform3f(p_uniform, val.x, val.y, val.z);
+ } break;
+ case Variant::PLANE: {
- Quat val=p_value;
- glUniform4f( p_uniform, val.x,val.y,val.z,val.w );
- } break;
+ Plane val = p_value;
+ glUniform4f(p_uniform, val.normal.x, val.normal.y, val.normal.z, val.d);
+ } break;
+ case Variant::QUAT: {
- case Variant::TRANSFORM2D: {
+ Quat val = p_value;
+ glUniform4f(p_uniform, val.x, val.y, val.z, val.w);
+ } break;
- Transform2D tr=p_value;
- GLfloat matrix[16]={ /* build a 16x16 matrix */
- tr.elements[0][0],
- tr.elements[0][1],
- 0,
- 0,
- tr.elements[1][0],
- tr.elements[1][1],
- 0,
- 0,
- 0,
- 0,
- 1,
- 0,
- tr.elements[2][0],
- tr.elements[2][1],
- 0,
- 1
- };
+ case Variant::TRANSFORM2D: {
- glUniformMatrix4fv(p_uniform,1,false,matrix);
+ Transform2D tr = p_value;
+ GLfloat matrix[16] = { /* build a 16x16 matrix */
+ tr.elements[0][0],
+ tr.elements[0][1],
+ 0,
+ 0,
+ tr.elements[1][0],
+ tr.elements[1][1],
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ tr.elements[2][0],
+ tr.elements[2][1],
+ 0,
+ 1
+ };
- } break;
- case Variant::BASIS:
- case Variant::TRANSFORM: {
+ glUniformMatrix4fv(p_uniform, 1, false, matrix);
- Transform tr=p_value;
- GLfloat matrix[16]={ /* build a 16x16 matrix */
- tr.basis.elements[0][0],
- tr.basis.elements[1][0],
- tr.basis.elements[2][0],
- 0,
- tr.basis.elements[0][1],
- tr.basis.elements[1][1],
- tr.basis.elements[2][1],
- 0,
- tr.basis.elements[0][2],
- tr.basis.elements[1][2],
- tr.basis.elements[2][2],
- 0,
- tr.origin.x,
- tr.origin.y,
- tr.origin.z,
- 1
- };
+ } break;
+ case Variant::BASIS:
+ case Variant::TRANSFORM: {
+ Transform tr = p_value;
+ GLfloat matrix[16] = { /* build a 16x16 matrix */
+ tr.basis.elements[0][0],
+ tr.basis.elements[1][0],
+ tr.basis.elements[2][0],
+ 0,
+ tr.basis.elements[0][1],
+ tr.basis.elements[1][1],
+ tr.basis.elements[2][1],
+ 0,
+ tr.basis.elements[0][2],
+ tr.basis.elements[1][2],
+ tr.basis.elements[2][2],
+ 0,
+ tr.origin.x,
+ tr.origin.y,
+ tr.origin.z,
+ 1
+ };
- glUniformMatrix4fv(p_uniform,1,false,matrix);
- } break;
- default: { ERR_FAIL(); } // do nothing
-
- }
+ glUniformMatrix4fv(p_uniform, 1, false, matrix);
+ } break;
+ default: { ERR_FAIL(); } // do nothing
+ }
}
- Map<uint32_t,Variant> uniform_defaults;
- Map<uint32_t,CameraMatrix> uniform_cameras;
-
-
-protected:
+ Map<uint32_t, Variant> uniform_defaults;
+ Map<uint32_t, CameraMatrix> uniform_cameras;
+protected:
_FORCE_INLINE_ int _get_uniform(int p_which) const;
_FORCE_INLINE_ void _set_conditional(int p_which, bool p_value);
-
- void setup(const char** p_conditional_defines, int p_conditional_count,const char** p_uniform_names,int p_uniform_count, const AttributePair* p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs,int p_ubo_pair_count, const Feedback* p_feedback, int p_feedback_count,const char*p_vertex_code, const char *p_fragment_code,int p_vertex_code_start,int p_fragment_code_start);
-
+
+ void setup(const char **p_conditional_defines, int p_conditional_count, const char **p_uniform_names, int p_uniform_count, const AttributePair *p_attribute_pairs, int p_attribute_count, const TexUnitPair *p_texunit_pairs, int p_texunit_pair_count, const UBOPair *p_ubo_pairs, int p_ubo_pair_count, const Feedback *p_feedback, int p_feedback_count, const char *p_vertex_code, const char *p_fragment_code, int p_vertex_code_start, int p_fragment_code_start);
+
ShaderGLES3();
+
public:
-
enum {
- CUSTOM_SHADER_DISABLED=0
+ CUSTOM_SHADER_DISABLED = 0
};
- GLint get_uniform_location(const String& p_name) const;
+ GLint get_uniform_location(const String &p_name) const;
GLint get_uniform_location(int p_uniform) const;
-
+
static _FORCE_INLINE_ ShaderGLES3 *get_active() { return active; };
bool bind();
void unbind();
void bind_uniforms();
-
- inline GLuint get_program() const { return version?version->id:0; }
-
+ inline GLuint get_program() const { return version ? version->id : 0; }
+
void clear_caches();
uint32_t create_custom_shader();
- void set_custom_shader_code(uint32_t p_id,const String& p_vertex, const String& p_vertex_globals,const String& p_fragment,const String& p_p_light,const String& p_fragment_globals,const String& p_uniforms,const Vector<StringName>& p_texture_uniforms,const Vector<CharString> &p_custom_defines);
+ void set_custom_shader_code(uint32_t p_id, const String &p_vertex, const String &p_vertex_globals, const String &p_fragment, const String &p_p_light, const String &p_fragment_globals, const String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines);
void set_custom_shader(uint32_t p_id);
void free_custom_shader(uint32_t p_id);
- void set_uniform_default(int p_idx, const Variant& p_value) {
+ void set_uniform_default(int p_idx, const Variant &p_value) {
- if (p_value.get_type()==Variant::NIL) {
+ if (p_value.get_type() == Variant::NIL) {
uniform_defaults.erase(p_idx);
} else {
- uniform_defaults[p_idx]=p_value;
+ uniform_defaults[p_idx] = p_value;
}
uniforms_dirty = true;
}
uint32_t get_version() const { return new_conditional_version.version; }
- void set_uniform_camera(int p_idx, const CameraMatrix& p_mat) {
+ void set_uniform_camera(int p_idx, const CameraMatrix &p_mat) {
uniform_cameras[p_idx] = p_mat;
uniforms_dirty = true;
};
- _FORCE_INLINE_ void set_texture_uniform(int p_idx, const Variant& p_value) {
+ _FORCE_INLINE_ void set_texture_uniform(int p_idx, const Variant &p_value) {
ERR_FAIL_COND(!version);
- ERR_FAIL_INDEX(p_idx,version->texture_uniform_locations.size());
- _set_uniform_variant( version->texture_uniform_locations[p_idx], p_value );
+ ERR_FAIL_INDEX(p_idx, version->texture_uniform_locations.size());
+ _set_uniform_variant(version->texture_uniform_locations[p_idx], p_value);
}
-
+
_FORCE_INLINE_ GLint get_texture_uniform_location(int p_idx) {
- ERR_FAIL_COND_V(!version,-1);
- ERR_FAIL_INDEX_V(p_idx,version->texture_uniform_locations.size(),-1);
+ ERR_FAIL_COND_V(!version, -1);
+ ERR_FAIL_INDEX_V(p_idx, version->texture_uniform_locations.size(), -1);
return version->texture_uniform_locations[p_idx];
}
- virtual void init()=0;
+ virtual void init() = 0;
void finish();
void set_base_material_tex_index(int p_idx);
- void add_custom_define(const String& p_define) {
+ void add_custom_define(const String &p_define) {
custom_defines.push_back(p_define.utf8());
}
virtual ~ShaderGLES3();
-
};
-
-// called a lot, made inline
-
+// called a lot, made inline
int ShaderGLES3::_get_uniform(int p_which) const {
-
- ERR_FAIL_INDEX_V( p_which, uniform_count,-1 );
- ERR_FAIL_COND_V( !version, -1 );
+
+ ERR_FAIL_INDEX_V(p_which, uniform_count, -1);
+ ERR_FAIL_COND_V(!version, -1);
return version->uniform_location[p_which];
}
void ShaderGLES3::_set_conditional(int p_which, bool p_value) {
-
- ERR_FAIL_INDEX(p_which,conditional_count);
+
+ ERR_FAIL_INDEX(p_which, conditional_count);
if (p_value)
- new_conditional_version.version|=(1<<p_which);
+ new_conditional_version.version |= (1 << p_which);
else
- new_conditional_version.version&=~(1<<p_which);
+ new_conditional_version.version &= ~(1 << p_which);
}
#endif
-
generated by cgit v1.2.3-70-g09d2 (git 2.51.2) at 2025-11-10 13:12:27 +0000