2017-03-05 15:47:28 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* rasterizer_gles3.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2017-03-05 15:47:28 +01:00
|
|
|
/*************************************************************************/
|
2018-01-01 14:40:08 +01:00
|
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
|
2017-03-05 15:47:28 +01:00
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2016-10-03 21:33:42 +02:00
|
|
|
#include "rasterizer_gles3.h"
|
2017-03-05 15:47:28 +01:00
|
|
|
|
2016-10-03 21:33:42 +02:00
|
|
|
#include "gl_context/context_gl.h"
|
2017-03-05 16:44:50 +01:00
|
|
|
#include "os/os.h"
|
2017-07-22 19:07:38 +02:00
|
|
|
#include "project_settings.h"
|
2016-10-03 21:33:42 +02:00
|
|
|
#include <string.h>
|
|
|
|
RasterizerStorage *RasterizerGLES3::get_storage() {
|
|
|
|
|
|
|
|
return storage;
|
|
|
|
}
|
|
|
|
|
|
|
|
RasterizerCanvas *RasterizerGLES3::get_canvas() {
|
|
|
|
|
|
|
|
return canvas;
|
|
|
|
}
|
|
|
|
|
|
|
|
RasterizerScene *RasterizerGLES3::get_scene() {
|
|
|
|
|
2016-10-19 16:14:41 +02:00
|
|
|
return scene;
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2016-11-23 00:51:56 +01:00
|
|
|
#define _EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242
|
|
|
|
#define _EXT_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243
|
|
|
|
#define _EXT_DEBUG_CALLBACK_FUNCTION_ARB 0x8244
|
|
|
|
#define _EXT_DEBUG_CALLBACK_USER_PARAM_ARB 0x8245
|
|
|
|
#define _EXT_DEBUG_SOURCE_API_ARB 0x8246
|
|
|
|
#define _EXT_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247
|
|
|
|
#define _EXT_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248
|
|
|
|
#define _EXT_DEBUG_SOURCE_THIRD_PARTY_ARB 0x8249
|
|
|
|
#define _EXT_DEBUG_SOURCE_APPLICATION_ARB 0x824A
|
|
|
|
#define _EXT_DEBUG_SOURCE_OTHER_ARB 0x824B
|
|
|
|
#define _EXT_DEBUG_TYPE_ERROR_ARB 0x824C
|
|
|
|
#define _EXT_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D
|
|
|
|
#define _EXT_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E
|
|
|
|
#define _EXT_DEBUG_TYPE_PORTABILITY_ARB 0x824F
|
|
|
|
#define _EXT_DEBUG_TYPE_PERFORMANCE_ARB 0x8250
|
|
|
|
#define _EXT_DEBUG_TYPE_OTHER_ARB 0x8251
|
|
|
|
#define _EXT_MAX_DEBUG_MESSAGE_LENGTH_ARB 0x9143
|
|
|
|
#define _EXT_MAX_DEBUG_LOGGED_MESSAGES_ARB 0x9144
|
|
|
|
#define _EXT_DEBUG_LOGGED_MESSAGES_ARB 0x9145
|
|
|
|
#define _EXT_DEBUG_SEVERITY_HIGH_ARB 0x9146
|
|
|
|
#define _EXT_DEBUG_SEVERITY_MEDIUM_ARB 0x9147
|
|
|
|
#define _EXT_DEBUG_SEVERITY_LOW_ARB 0x9148
|
|
|
|
#define _EXT_DEBUG_OUTPUT 0x92E0
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-04-29 16:48:23 +02:00
|
|
|
#if (defined WINDOWS_ENABLED) && !(defined UWP_ENABLED)
|
2016-12-24 20:23:30 +01:00
|
|
|
#define GLAPIENTRY APIENTRY
|
|
|
|
#else
|
|
|
|
#define GLAPIENTRY
|
|
|
|
#endif
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
static void GLAPIENTRY _gl_debug_print(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const GLvoid *userParam) {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (type == _EXT_DEBUG_TYPE_OTHER_ARB)
|
2016-10-03 21:33:42 +02:00
|
|
|
return;
|
|
|
|
|
2017-11-07 01:52:30 +01:00
|
|
|
if (type == _EXT_DEBUG_TYPE_PERFORMANCE_ARB)
|
|
|
|
return; //these are ultimately annoying, so removing for now
|
|
|
|
|
2016-10-03 21:33:42 +02:00
|
|
|
char debSource[256], debType[256], debSev[256];
|
2017-03-05 16:44:50 +01:00
|
|
|
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");
|
|
|
|
|
|
|
|
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;
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
ERR_PRINTS(output);
|
|
|
|
}
|
|
|
|
|
2016-11-23 00:51:56 +01:00
|
|
|
typedef void (*DEBUGPROCARB)(GLenum source,
|
2017-03-05 16:44:50 +01:00
|
|
|
GLenum type,
|
|
|
|
GLuint id,
|
|
|
|
GLenum severity,
|
|
|
|
GLsizei length,
|
|
|
|
const char *message,
|
|
|
|
const void *userParam);
|
2016-11-23 00:51:56 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
typedef void (*DebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userParam);
|
2016-11-23 00:51:56 +01:00
|
|
|
|
2016-10-03 21:33:42 +02:00
|
|
|
void RasterizerGLES3::initialize() {
|
|
|
|
|
|
|
|
if (OS::get_singleton()->is_stdout_verbose()) {
|
|
|
|
print_line("Using GLES3 video driver");
|
|
|
|
}
|
|
|
|
|
2017-11-19 20:47:53 +01:00
|
|
|
#ifdef GLAD_ENABLED
|
|
|
|
if (!gladLoadGL()) {
|
|
|
|
ERR_PRINT("Error initializing GLAD");
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-11-19 20:47:53 +01:00
|
|
|
// GLVersion seems to be used for both GL and GL ES, so we need different version checks for them
|
|
|
|
#ifdef OPENGL_ENABLED // OpenGL 3.3 Core Profile required
|
|
|
|
if (GLVersion.major < 3 && GLVersion.minor < 3) {
|
|
|
|
#else // OpenGL ES 3.0
|
|
|
|
if (GLVersion.major < 3) {
|
|
|
|
#endif
|
|
|
|
ERR_PRINT("Your system's graphic drivers seem not to support OpenGL 3.3 / OpenGL ES 3.0, sorry :(\n"
|
2017-03-05 16:44:50 +01:00
|
|
|
"Try a drivers update, buy a new GPU or try software rendering on Linux; Godot will now crash with a segmentation fault.");
|
2017-11-19 20:47:53 +01:00
|
|
|
OS::get_singleton()->alert("Your system's graphic drivers seem not to support OpenGL 3.3 / OpenGL ES 3.0, sorry :(\n"
|
2017-03-05 16:44:50 +01:00
|
|
|
"Godot Engine will self-destruct as soon as you acknowledge this error message.",
|
2017-11-19 20:47:53 +01:00
|
|
|
"Fatal error: Insufficient OpenGL / GLES driver support");
|
2016-11-23 00:51:56 +01:00
|
|
|
}
|
|
|
|
|
2017-11-13 17:40:07 +01:00
|
|
|
if (OS::get_singleton()->is_stdout_verbose()) {
|
2018-03-05 19:30:04 +01:00
|
|
|
if (GLAD_GL_ARB_debug_output) {
|
|
|
|
glEnable(_EXT_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
|
|
|
|
glDebugMessageCallbackARB(_gl_debug_print, NULL);
|
|
|
|
glEnable(_EXT_DEBUG_OUTPUT);
|
|
|
|
} else {
|
|
|
|
print_line("OpenGL debugging not supported!");
|
|
|
|
}
|
2017-11-13 17:40:07 +01:00
|
|
|
}
|
2016-11-23 00:51:56 +01:00
|
|
|
|
2017-11-19 20:47:53 +01:00
|
|
|
#endif // GLAD_ENABLED
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-11-19 20:47:53 +01:00
|
|
|
/* // For debugging
|
2018-03-05 19:30:04 +01:00
|
|
|
if (GLAD_GL_ARB_debug_output) {
|
|
|
|
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);
|
|
|
|
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_PERFORMANCE_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
|
|
|
|
glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB,GL_DEBUG_TYPE_OTHER_ARB,GL_DEBUG_SEVERITY_HIGH_ARB,0,NULL,GL_TRUE);
|
|
|
|
glDebugMessageInsertARB(
|
|
|
|
GL_DEBUG_SOURCE_API_ARB,
|
|
|
|
GL_DEBUG_TYPE_OTHER_ARB, 1,
|
|
|
|
GL_DEBUG_SEVERITY_HIGH_ARB,5, "hello");
|
|
|
|
}
|
2017-11-19 20:47:53 +01:00
|
|
|
*/
|
2017-07-22 19:07:38 +02:00
|
|
|
|
|
|
|
const GLubyte *renderer = glGetString(GL_RENDERER);
|
|
|
|
print_line("OpenGL ES 3.0 Renderer: " + String((const char *)renderer));
|
2016-10-03 21:33:42 +02:00
|
|
|
storage->initialize();
|
|
|
|
canvas->initialize();
|
2016-10-19 16:14:41 +02:00
|
|
|
scene->initialize();
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void RasterizerGLES3::begin_frame() {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-01-02 02:16:52 +01:00
|
|
|
uint64_t tick = OS::get_singleton()->get_ticks_usec();
|
|
|
|
|
2017-08-08 13:25:35 +02:00
|
|
|
double delta = double(tick - prev_ticks) / 1000000.0;
|
|
|
|
delta *= Engine::get_singleton()->get_time_scale();
|
|
|
|
|
|
|
|
time_total += delta;
|
|
|
|
|
2017-08-08 13:31:34 +02:00
|
|
|
if (delta == 0) {
|
|
|
|
//to avoid hiccups
|
|
|
|
delta = 0.001;
|
|
|
|
}
|
|
|
|
|
2017-08-08 13:25:35 +02:00
|
|
|
prev_ticks = tick;
|
|
|
|
|
|
|
|
double time_roll_over = GLOBAL_GET("rendering/limits/time/time_rollover_secs");
|
|
|
|
if (time_total > time_roll_over)
|
|
|
|
time_total = 0; //roll over every day (should be customz
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
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);
|
2016-11-19 17:23:37 +01:00
|
|
|
storage->frame.count++;
|
2017-08-08 13:31:34 +02:00
|
|
|
storage->frame.delta = delta;
|
2017-01-02 02:16:52 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
storage->frame.prev_tick = tick;
|
2017-01-02 02:16:52 +01:00
|
|
|
|
2017-02-16 12:55:11 +01:00
|
|
|
storage->update_dirty_resources();
|
2016-10-10 23:31:01 +02:00
|
|
|
|
2017-06-11 23:13:04 +02:00
|
|
|
storage->info.render_final = storage->info.render;
|
|
|
|
storage->info.render.reset();
|
2016-12-21 18:20:35 +01:00
|
|
|
|
2016-11-11 16:27:52 +01:00
|
|
|
scene->iteration();
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
2016-10-10 23:31:01 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void RasterizerGLES3::set_current_render_target(RID p_render_target) {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
if (!p_render_target.is_valid() && storage->frame.current_rt && storage->frame.clear_request) {
|
|
|
|
//handle pending clear request, if the framebuffer was not cleared
|
2017-03-05 16:44:50 +01:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, storage->frame.current_rt->fbo);
|
|
|
|
print_line("unbind clear of: " + storage->frame.clear_request_color);
|
2016-10-03 21:33:42 +02:00
|
|
|
glClearColor(
|
2017-03-05 16:44:50 +01:00
|
|
|
storage->frame.clear_request_color.r,
|
|
|
|
storage->frame.clear_request_color.g,
|
|
|
|
storage->frame.clear_request_color.b,
|
|
|
|
storage->frame.clear_request_color.a);
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p_render_target.is_valid()) {
|
2017-03-05 16:44:50 +01:00
|
|
|
RasterizerStorageGLES3::RenderTarget *rt = storage->render_target_owner.getornull(p_render_target);
|
|
|
|
storage->frame.current_rt = rt;
|
2017-08-25 17:14:33 +02:00
|
|
|
ERR_FAIL_COND(!rt);
|
2017-03-05 16:44:50 +01:00
|
|
|
storage->frame.clear_request = false;
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
glViewport(0, 0, rt->width, rt->height);
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
} else {
|
2017-03-05 16:44:50 +01:00
|
|
|
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);
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerGLES3::restore_render_target() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
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);
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void RasterizerGLES3::clear_render_target(const Color &p_color) {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
ERR_FAIL_COND(!storage->frame.current_rt);
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
storage->frame.clear_request = true;
|
|
|
|
storage->frame.clear_request_color = p_color;
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-05-17 12:36:47 +02:00
|
|
|
void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale) {
|
2017-04-10 01:02:04 +02:00
|
|
|
|
2017-05-17 12:36:47 +02:00
|
|
|
if (p_image.is_null() || p_image->empty())
|
2017-04-10 01:02:04 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
begin_frame();
|
|
|
|
|
|
|
|
int window_w = OS::get_singleton()->get_video_mode(0).width;
|
|
|
|
int window_h = OS::get_singleton()->get_video_mode(0).height;
|
|
|
|
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
|
|
|
glViewport(0, 0, window_w, window_h);
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
glDepthMask(GL_FALSE);
|
2017-12-10 19:38:26 +01:00
|
|
|
if (OS::get_singleton()->get_window_per_pixel_transparency_enabled()) {
|
|
|
|
glClearColor(0.0, 0.0, 0.0, 0.0);
|
|
|
|
} else {
|
|
|
|
glClearColor(p_color.r, p_color.g, p_color.b, 1.0);
|
|
|
|
}
|
2017-04-10 01:02:04 +02:00
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
canvas->canvas_begin();
|
|
|
|
|
|
|
|
RID texture = storage->texture_create();
|
2017-05-17 12:36:47 +02:00
|
|
|
storage->texture_allocate(texture, p_image->get_width(), p_image->get_height(), p_image->get_format(), VS::TEXTURE_FLAG_FILTER);
|
2017-04-10 01:02:04 +02:00
|
|
|
storage->texture_set_data(texture, p_image);
|
|
|
|
|
2017-05-17 12:36:47 +02:00
|
|
|
Rect2 imgrect(0, 0, p_image->get_width(), p_image->get_height());
|
2017-04-10 01:02:04 +02:00
|
|
|
Rect2 screenrect;
|
|
|
|
if (p_scale) {
|
|
|
|
|
|
|
|
if (window_w > window_h) {
|
|
|
|
//scale horizontally
|
|
|
|
screenrect.size.y = window_h;
|
|
|
|
screenrect.size.x = imgrect.size.x * window_h / imgrect.size.y;
|
2017-06-04 00:25:13 +02:00
|
|
|
screenrect.position.x = (window_w - screenrect.size.x) / 2;
|
2017-04-10 01:02:04 +02:00
|
|
|
|
|
|
|
} else {
|
|
|
|
//scale vertically
|
|
|
|
screenrect.size.x = window_w;
|
|
|
|
screenrect.size.y = imgrect.size.y * window_w / imgrect.size.x;
|
2017-06-04 00:25:13 +02:00
|
|
|
screenrect.position.y = (window_h - screenrect.size.y) / 2;
|
2017-04-10 01:02:04 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
screenrect = imgrect;
|
2017-06-04 00:25:13 +02:00
|
|
|
screenrect.position += ((Size2(window_w, window_h) - screenrect.size) / 2.0).floor();
|
2017-04-10 01:02:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
RasterizerStorageGLES3::Texture *t = storage->texture_owner.get(texture);
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, t->tex_id);
|
|
|
|
canvas->draw_generic_textured_rect(screenrect, Rect2(0, 0, 1, 1));
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
canvas->canvas_end();
|
|
|
|
|
|
|
|
storage->free(texture); // free since it's only one frame that stays there
|
|
|
|
|
2017-12-10 19:38:26 +01:00
|
|
|
if (OS::get_singleton()->is_layered_allowed()) {
|
|
|
|
if (OS::get_singleton()->get_window_per_pixel_transparency_enabled()) {
|
|
|
|
#ifdef WINDOWS_ENABLED
|
|
|
|
Size2 wndsize = OS::get_singleton()->get_layered_buffer_size();
|
|
|
|
uint8_t *data = OS::get_singleton()->get_layered_buffer_data();
|
|
|
|
if (data) {
|
|
|
|
glReadPixels(0, 0, wndsize.x, wndsize.y, GL_BGRA, GL_UNSIGNED_BYTE, data);
|
|
|
|
OS::get_singleton()->swap_layered_buffer();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
//clear alpha
|
|
|
|
glColorMask(false, false, false, true);
|
|
|
|
glClearColor(0, 0, 0, 1);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glColorMask(true, true, true, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-10 01:02:04 +02:00
|
|
|
OS::get_singleton()->swap_buffers();
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void RasterizerGLES3::blit_render_target_to_screen(RID p_render_target, const Rect2 &p_screen_rect, int p_screen) {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND(storage->frame.current_rt);
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
RasterizerStorageGLES3::RenderTarget *rt = storage->render_target_owner.getornull(p_render_target);
|
|
|
|
ERR_FAIL_COND(!rt);
|
|
|
|
|
2018-01-02 22:44:09 +01:00
|
|
|
#if 1
|
|
|
|
|
|
|
|
Size2 win_size = OS::get_singleton()->get_window_size();
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, rt->fbo);
|
|
|
|
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2018-01-10 02:38:04 +01:00
|
|
|
glBlitFramebuffer(0, 0, rt->width, rt->height, p_screen_rect.position.x, win_size.height - p_screen_rect.position.y - p_screen_rect.size.height, p_screen_rect.position.x + p_screen_rect.size.width, win_size.height - p_screen_rect.position.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
2018-01-02 22:44:09 +01:00
|
|
|
|
|
|
|
#else
|
2016-10-03 21:33:42 +02:00
|
|
|
canvas->canvas_begin();
|
2016-10-05 06:26:35 +02:00
|
|
|
glDisable(GL_BLEND);
|
2017-03-05 16:44:50 +01:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, RasterizerStorageGLES3::system_fbo);
|
2016-10-03 21:33:42 +02:00
|
|
|
glActiveTexture(GL_TEXTURE0);
|
2017-03-05 16:44:50 +01:00
|
|
|
glBindTexture(GL_TEXTURE_2D, rt->color);
|
2017-07-22 19:07:38 +02:00
|
|
|
//glBindTexture(GL_TEXTURE_2D, rt->effects.mip_maps[0].color);
|
|
|
|
glActiveTexture(GL_TEXTURE1);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, storage->resources.normal_tex);
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
canvas->draw_generic_textured_rect(p_screen_rect, Rect2(0, 0, 1, -1));
|
|
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
2016-10-03 21:33:42 +02:00
|
|
|
canvas->canvas_end();
|
2018-01-02 22:44:09 +01:00
|
|
|
#endif
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-10-30 21:33:36 +01:00
|
|
|
void RasterizerGLES3::end_frame(bool p_swap_buffers) {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-12-10 19:38:26 +01:00
|
|
|
if (OS::get_singleton()->is_layered_allowed()) {
|
|
|
|
if (OS::get_singleton()->get_window_per_pixel_transparency_enabled()) {
|
|
|
|
#ifdef WINDOWS_ENABLED
|
|
|
|
Size2 wndsize = OS::get_singleton()->get_layered_buffer_size();
|
|
|
|
uint8_t *data = OS::get_singleton()->get_layered_buffer_data();
|
|
|
|
if (data) {
|
|
|
|
glReadPixels(0, 0, wndsize.x, wndsize.y, GL_BGRA, GL_UNSIGNED_BYTE, data);
|
|
|
|
OS::get_singleton()->swap_layered_buffer();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
//clear alpha
|
|
|
|
glColorMask(false, false, false, true);
|
|
|
|
glClearColor(0, 0, 0, 1);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glColorMask(true, true, true, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-30 21:33:36 +01:00
|
|
|
if (p_swap_buffers)
|
|
|
|
OS::get_singleton()->swap_buffers();
|
|
|
|
else
|
|
|
|
glFinish();
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void RasterizerGLES3::finalize() {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
storage->finalize();
|
|
|
|
canvas->finalize();
|
|
|
|
}
|
|
|
|
|
|
|
|
Rasterizer *RasterizerGLES3::_create_current() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
return memnew(RasterizerGLES3);
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerGLES3::make_current() {
|
2017-03-05 16:44:50 +01:00
|
|
|
_create_func = _create_current;
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void RasterizerGLES3::register_config() {
|
|
|
|
|
2017-07-18 02:05:38 +02:00
|
|
|
GLOBAL_DEF("rendering/quality/filters/use_nearest_mipmap_filter", false);
|
2017-11-25 06:49:23 +01:00
|
|
|
GLOBAL_DEF("rendering/quality/filters/anisotropic_filter_level", 4);
|
|
|
|
ProjectSettings::get_singleton()->set_custom_property_info("rendering/quality/filters/anisotropic_filter_level", PropertyInfo(Variant::INT, "rendering/quality/filters/anisotropic_filter_level", PROPERTY_HINT_RANGE, "1,16,1"));
|
2017-08-08 13:25:35 +02:00
|
|
|
GLOBAL_DEF("rendering/limits/time/time_rollover_secs", 3600);
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
RasterizerGLES3::RasterizerGLES3() {
|
2016-10-03 21:33:42 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
storage = memnew(RasterizerStorageGLES3);
|
|
|
|
canvas = memnew(RasterizerCanvasGLES3);
|
|
|
|
scene = memnew(RasterizerSceneGLES3);
|
|
|
|
canvas->storage = storage;
|
2017-06-27 03:58:03 +02:00
|
|
|
canvas->scene_render = scene;
|
2017-03-05 16:44:50 +01:00
|
|
|
storage->canvas = canvas;
|
|
|
|
scene->storage = storage;
|
|
|
|
storage->scene = scene;
|
2017-08-08 13:25:35 +02:00
|
|
|
|
|
|
|
prev_ticks = 0;
|
|
|
|
time_total = 0;
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
RasterizerGLES3::~RasterizerGLES3() {
|
|
|
|
|
|
|
|
memdelete(storage);
|
|
|
|
memdelete(canvas);
|
2018-03-13 02:40:47 +01:00
|
|
|
memdelete(scene);
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|