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