gaming/godot
gaming/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot synced 2024-09-18 21:41:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initialize OpenGL before rasterizers in GLES3

Browse source
This commit is contained in:
clayjohn 2022-04-19 09:54:30 -07:00
parent 1d2177938d
commit 3a4b9b47fd
7 changed files with 64 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/gles3/rasterizer_canvas_gles3.cpp
View file

@ -1471,8 +1471,10 @@ RasterizerCanvasGLES3 *RasterizerCanvasGLES3::get_singleton() {
return singleton; return singleton;
} }
RasterizerCanvasGLES3::RasterizerCanvasGLES3() { RasterizerCanvasGLES3::RasterizerCanvasGLES3(RasterizerStorageGLES3 *p_storage) {
singleton = this; singleton = this;
storage = p_storage;
initialize();
} }
RasterizerCanvasGLES3::~RasterizerCanvasGLES3() { RasterizerCanvasGLES3::~RasterizerCanvasGLES3() {

4
drivers/gles3/rasterizer_canvas_gles3.h
View file

@ -219,8 +219,6 @@ public:
typedef void Texture; typedef void Texture;
RasterizerSceneGLES3 *scene_render = nullptr;
RasterizerStorageGLES3 *storage = nullptr; RasterizerStorageGLES3 *storage = nullptr;
void _set_uniforms(); void _set_uniforms();
@ -279,7 +277,7 @@ public:
void finalize(); void finalize();
static RasterizerCanvasGLES3 *get_singleton(); static RasterizerCanvasGLES3 *get_singleton();
RasterizerCanvasGLES3(); RasterizerCanvasGLES3(RasterizerStorageGLES3 *storage);
~RasterizerCanvasGLES3(); ~RasterizerCanvasGLES3();
}; };

63
drivers/gles3/rasterizer_gles3.cpp
View file

@ -102,10 +102,10 @@ void RasterizerGLES3::begin_frame(double frame_step) {
texture_storage->frame.count++; texture_storage->frame.count++;
texture_storage->frame.delta = frame_step; texture_storage->frame.delta = frame_step;
storage.update_dirty_resources(); storage->update_dirty_resources();
storage.info.render_final = storage.info.render; storage->info.render_final = storage->info.render;
storage.info.render.reset(); storage->info.render.reset();
//scene->iteration(); //scene->iteration();
} }
@ -196,10 +196,14 @@ typedef void (*DEBUGPROCARB)(GLenum source,
typedef void (*DebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userParam); typedef void (*DebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userParam);
void RasterizerGLES3::initialize() { void RasterizerGLES3::initialize() {
print_verbose("Using OpenGL video driver"); print_line("OpenGL Renderer: " + RS::get_singleton()->get_video_adapter_name());
texture_storage.set_main_thread_id(Thread::get_caller_id()); texture_storage->set_main_thread_id(Thread::get_caller_id());
// make sure the OS knows to only access the renderer from the main thread
OS::get_singleton()->set_render_main_thread_mode(OS::RENDER_MAIN_THREAD_ONLY);
}
RasterizerGLES3::RasterizerGLES3() {
#ifdef GLAD_ENABLED #ifdef GLAD_ENABLED
if (!gladLoadGL()) { if (!gladLoadGL()) {
ERR_PRINT("Error initializing GLAD"); ERR_PRINT("Error initializing GLAD");
@ -251,21 +255,28 @@ void RasterizerGLES3::initialize() {
#endif // GLES_OVER_GL #endif // GLES_OVER_GL
#endif // CAN_DEBUG #endif // CAN_DEBUG
print_line("OpenGL Renderer: " + RS::get_singleton()->get_video_adapter_name()); // OpenGL needs to be initialized before initializing the Rasterizers
storage.initialize(); config = memnew(GLES3::Config);
canvas.initialize(); texture_storage = memnew(GLES3::TextureStorage);
// scene.initialize(); material_storage = memnew(GLES3::MaterialStorage);
mesh_storage = memnew(GLES3::MeshStorage);
// make sure the OS knows to only access the renderer from the main thread particles_storage = memnew(GLES3::ParticlesStorage);
OS::get_singleton()->set_render_main_thread_mode(OS::RENDER_MAIN_THREAD_ONLY); light_storage = memnew(GLES3::LightStorage);
storage = memnew(RasterizerStorageGLES3);
canvas = memnew(RasterizerCanvasGLES3(storage));
scene = memnew(RasterizerSceneGLES3);
} }
RasterizerGLES3::RasterizerGLES3() { RasterizerGLES3::~RasterizerGLES3() {
canvas.storage = &storage; memdelete(scene);
canvas.scene_render = &scene; memdelete(canvas);
//storage.canvas = &canvas; memdelete(storage);
//scene.storage = &storage; memdelete(light_storage);
//storage.scene = &scene; memdelete(particles_storage);
memdelete(mesh_storage);
memdelete(material_storage);
memdelete(texture_storage);
memdelete(config);
} }
void RasterizerGLES3::prepare_for_blitting_render_targets() { void RasterizerGLES3::prepare_for_blitting_render_targets() {
@ -327,12 +338,12 @@ void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_c
} }
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
canvas.canvas_begin(); canvas->canvas_begin();
RID texture = texture_storage.texture_create(); RID texture = texture_storage->texture_create();
//texture_storage.texture_allocate(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), VS::TEXTURE_TYPE_2D, p_use_filter ? VS::TEXTURE_FLAG_FILTER : 0); //texture_storage.texture_allocate(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), VS::TEXTURE_TYPE_2D, p_use_filter ? VS::TEXTURE_FLAG_FILTER : 0);
texture_storage._texture_allocate_internal(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D); texture_storage->_texture_allocate_internal(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D);
texture_storage.texture_set_data(texture, p_image); texture_storage->texture_set_data(texture, p_image);
Rect2 imgrect(0, 0, p_image->get_width(), p_image->get_height()); Rect2 imgrect(0, 0, p_image->get_width(), p_image->get_height());
Rect2 screenrect; Rect2 screenrect;
@ -354,13 +365,13 @@ void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_c
screenrect.position += ((Size2(win_size.width, win_size.height) - screenrect.size) / 2.0).floor(); screenrect.position += ((Size2(win_size.width, win_size.height) - screenrect.size) / 2.0).floor();
} }
GLES3::Texture *t = texture_storage.get_texture(texture); GLES3::Texture *t = texture_storage->get_texture(texture);
glActiveTexture(GL_TEXTURE0 + config.max_texture_image_units - 1); glActiveTexture(GL_TEXTURE0 + config->max_texture_image_units - 1);
glBindTexture(GL_TEXTURE_2D, t->tex_id); glBindTexture(GL_TEXTURE_2D, t->tex_id);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
canvas.canvas_end(); canvas->canvas_end();
texture_storage.texture_free(texture); texture_storage->texture_free(texture);
end_frame(true); end_frame(true);
} }

36
drivers/gles3/rasterizer_gles3.h
View file

@ -52,27 +52,27 @@ private:
double time_total = 0.0; double time_total = 0.0;
protected: protected:
GLES3::Config config; GLES3::Config *config = nullptr;
GLES3::TextureStorage texture_storage; GLES3::TextureStorage *texture_storage = nullptr;
GLES3::MaterialStorage material_storage; GLES3::MaterialStorage *material_storage = nullptr;
GLES3::MeshStorage mesh_storage; GLES3::MeshStorage *mesh_storage = nullptr;
GLES3::ParticlesStorage particles_storage; GLES3::ParticlesStorage *particles_storage = nullptr;
GLES3::LightStorage light_storage; GLES3::LightStorage *light_storage = nullptr;
RasterizerStorageGLES3 storage; RasterizerStorageGLES3 *storage = nullptr;
RasterizerCanvasGLES3 canvas; RasterizerCanvasGLES3 *canvas = nullptr;
RasterizerSceneGLES3 scene; RasterizerSceneGLES3 *scene = nullptr;
void _blit_render_target_to_screen(RID p_render_target, DisplayServer::WindowID p_screen, const Rect2 &p_screen_rect); void _blit_render_target_to_screen(RID p_render_target, DisplayServer::WindowID p_screen, const Rect2 &p_screen_rect);
public: public:
RendererLightStorage *get_light_storage() { return &light_storage; } RendererLightStorage *get_light_storage() { return light_storage; }
RendererMaterialStorage *get_material_storage() { return &material_storage; } RendererMaterialStorage *get_material_storage() { return material_storage; }
RendererMeshStorage *get_mesh_storage() { return &mesh_storage; } RendererMeshStorage *get_mesh_storage() { return mesh_storage; }
RendererParticlesStorage *get_particles_storage() { return &particles_storage; } RendererParticlesStorage *get_particles_storage() { return particles_storage; }
RendererTextureStorage *get_texture_storage() { return &texture_storage; } RendererTextureStorage *get_texture_storage() { return texture_storage; }
RendererStorage *get_storage() { return &storage; } RendererStorage *get_storage() { return storage; }
RendererCanvasRender *get_canvas() { return &canvas; } RendererCanvasRender *get_canvas() { return canvas; }
RendererSceneRender *get_scene() { return &scene; } RendererSceneRender *get_scene() { return scene; }
void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter = true); void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter = true);
@ -99,7 +99,7 @@ public:
double get_frame_delta_time() const { return delta; } double get_frame_delta_time() const { return delta; }
RasterizerGLES3(); RasterizerGLES3();
~RasterizerGLES3() {} ~RasterizerGLES3();
}; };
#endif // GLES3_ENABLED #endif // GLES3_ENABLED

2
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -651,7 +651,6 @@ RenderingDevice::DeviceType RasterizerStorageGLES3::get_video_adapter_type() con
void RasterizerStorageGLES3::initialize() { void RasterizerStorageGLES3::initialize() {
config = GLES3::Config::get_singleton(); config = GLES3::Config::get_singleton();
// config->initialize();
//picky requirements for these //picky requirements for these
config->support_shadow_cubemaps = config->support_depth_texture && config->support_write_depth && config->support_depth_cubemaps; config->support_shadow_cubemaps = config->support_depth_texture && config->support_write_depth && config->support_depth_cubemaps;
@ -824,6 +823,7 @@ void RasterizerStorageGLES3::update_dirty_resources() {
} }
RasterizerStorageGLES3::RasterizerStorageGLES3() { RasterizerStorageGLES3::RasterizerStorageGLES3() {
initialize();
} }
RasterizerStorageGLES3::~RasterizerStorageGLES3() { RasterizerStorageGLES3::~RasterizerStorageGLES3() {

15
drivers/gles3/storage/config.cpp
View file

@ -39,18 +39,7 @@ Config *Config::singleton = nullptr;
Config::Config() { Config::Config() {
singleton = this; singleton = this;
should_orphan = true;
// If this is to early we need to change our code similar to what we're doing in RendererRD,
// and instantiate our storage classes when we are ready to do so in the order we want.
initialize();
}
Config::~Config() {
singleton = nullptr;
}
void Config::initialize() {
{ {
const GLubyte *extension_string = glGetString(GL_EXTENSIONS); const GLubyte *extension_string = glGetString(GL_EXTENSIONS);
@ -157,4 +146,8 @@ void Config::initialize() {
// should_orphan = GLOBAL_GET("rendering/options/api_usage_legacy/orphan_buffers"); // should_orphan = GLOBAL_GET("rendering/options/api_usage_legacy/orphan_buffers");
} }
Config::~Config() {
singleton = nullptr;
}
#endif // GLES3_ENABLED #endif // GLES3_ENABLED

1
drivers/gles3/storage/config.h
View file

@ -103,7 +103,6 @@ public:
Config(); Config();
~Config(); ~Config();
void initialize();
}; };
} // namespace GLES3 } // namespace GLES3