asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/drivers/gles3/storage/texture_storage.h

709 lines
27 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* texture_storage.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
#ifndef TEXTURE_STORAGE_GLES3_H
#define TEXTURE_STORAGE_GLES3_H
#ifdef GLES3_ENABLED
[macOS/Windows] Add optional ANGLE backed OpenGL renderer support. Add EGL_ANDROID_blob_cache caching. Co-authored-by: Riteo <riteo@posteo.net>
2021-11-12 13:49:49 +01:00
#include "platform_gl.h"
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
#include "config.h"
#include "core/os/os.h"
#include "core/templates/rid_owner.h"
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
#include "servers/rendering/renderer_compositor.h"
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
#include "servers/rendering/storage/texture_storage.h"
Allow for external python scripts to call the build python headers via external scripts Change GLES3 to not use a relative path Make the parameters more explicit and ensure the shaders generated are not using relative paths
2023-03-20 05:01:58 +01:00
#include "drivers/gles3/shaders/canvas_sdf.glsl.gen.h"
Add 2D shadows and canvas SDF to OpenGL3 renderer This is an initial implementation based on the current RD implementation Performance will improve later
2022-10-19 02:59:31 +02:00
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
namespace GLES3 {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
#define _GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
#define _GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
#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_RED_RGTC1_EXT 0x8DBB
#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
#define _EXT_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
#define _EXT_COMPRESSED_RG_RGTC2 0x8DBD
#define _EXT_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
#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_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
#define _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
#define _EXT_COMPRESSED_R11_EAC 0x9270
#define _EXT_COMPRESSED_SIGNED_R11_EAC 0x9271
#define _EXT_COMPRESSED_RG11_EAC 0x9272
#define _EXT_COMPRESSED_SIGNED_RG11_EAC 0x9273
#define _EXT_COMPRESSED_RGB8_ETC2 0x9274
#define _EXT_COMPRESSED_SRGB8_ETC2 0x9275
#define _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
#define _EXT_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
#define _EXT_COMPRESSED_RGBA8_ETC2_EAC 0x9278
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
Refactor high quality texture import * Only two texture import modes for low/high quality now: * S3TC/BPTC * ETC2/ASTC * Makes sense given this is the general preferred and most compatible combination in most platforms. * Removed lossy_quality from VRAM texture compression options. It was unused everywhere. * Added a new "high_quality" option to texture import. When enabled, it uses BPTC/ASTC (BC7/ASTC4x4) instead of S3TC/ETC2 (DXT1-5/ETC2,ETCA). * Changed MacOS export settings so required texture formats depend on the architecture selected. This solves the following problems: * Makes it simpler to import textures as high quality, without having to worry about the specific format used. * As the editor can now run on platforms such as web, Mac OS with Apple Silicion and Android, it should no longer be assumed that S3TC/BPTC is available by default for it.
2023-01-25 12:17:11 +01:00
#define _EXT_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0
#define _EXT_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1
#define _EXT_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2
#define _EXT_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3
#define _EXT_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4
#define _EXT_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5
#define _EXT_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6
#define _EXT_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7
#define _EXT_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8
#define _EXT_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9
#define _EXT_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA
#define _EXT_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB
#define _EXT_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC
#define _EXT_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC
#define _EXT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
#define _GL_TEXTURE_EXTERNAL_OES 0x8D65
#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
enum DefaultGLTexture {
DEFAULT_GL_TEXTURE_WHITE,
DEFAULT_GL_TEXTURE_BLACK,
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
DEFAULT_GL_TEXTURE_TRANSPARENT,
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
DEFAULT_GL_TEXTURE_NORMAL,
DEFAULT_GL_TEXTURE_ANISO,
DEFAULT_GL_TEXTURE_DEPTH,
DEFAULT_GL_TEXTURE_CUBEMAP_BLACK,
//DEFAULT_GL_TEXTURE_CUBEMAP_ARRAY_BLACK, // Cubemap Arrays not supported in GL 3.3 or GL ES 3.0
DEFAULT_GL_TEXTURE_CUBEMAP_WHITE,
DEFAULT_GL_TEXTURE_3D_WHITE,
DEFAULT_GL_TEXTURE_3D_BLACK,
DEFAULT_GL_TEXTURE_2D_ARRAY_WHITE,
DEFAULT_GL_TEXTURE_2D_UINT,
DEFAULT_GL_TEXTURE_MAX
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
};
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
struct CanvasTexture {
RID diffuse;
RID normal_map;
RID specular;
Color specular_color = Color(1, 1, 1, 1);
float shininess = 1.0;
RS::CanvasItemTextureFilter texture_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
RS::CanvasItemTextureRepeat texture_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
};
struct RenderTarget;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
struct Texture {
RID self;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool is_proxy = false;
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
bool is_external = false;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool is_render_target = false;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
RID proxy_to;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Vector<RID> proxies;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
String path;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
int width = 0;
int height = 0;
int depth = 0;
int mipmaps = 1;
int layers = 1;
int alloc_width = 0;
int alloc_height = 0;
Image::Format format = Image::FORMAT_R8;
Basic 3D rendering
2022-05-10 19:02:44 +02:00
Image::Format real_format = Image::FORMAT_R8;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
enum Type {
TYPE_2D,
TYPE_LAYERED,
TYPE_3D
};
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Type type;
RS::TextureLayeredType layered_type = RS::TEXTURE_LAYERED_2D_ARRAY;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
GLenum target = GL_TEXTURE_2D;
GLenum gl_format_cache = 0;
GLenum gl_internal_format_cache = 0;
GLenum gl_type_cache = 0;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
int total_data_size = 0;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool compressed = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool resize_to_po2 = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool active = false;
GLuint tex_id = 0;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
uint16_t stored_cube_sides = 0;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Zero initialize all pointer class and struct members This prevents the pitfall of UB when checking if they have been assigned something valid by comparing to nullptr.
2022-04-04 15:06:57 +02:00
RenderTarget *render_target = nullptr;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Ref<Image> image_cache_2d;
OpenGL: Implement 3D Texture support
2023-08-07 10:41:09 +02:00
Vector<Ref<Image>> image_cache_3d;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
bool redraw_if_visible = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
RS::TextureDetectCallback detect_3d_callback = nullptr;
void *detect_3d_callback_ud = nullptr;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
RS::TextureDetectCallback detect_normal_callback = nullptr;
void *detect_normal_callback_ud = nullptr;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
RS::TextureDetectRoughnessCallback detect_roughness_callback = nullptr;
void *detect_roughness_callback_ud = nullptr;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
CanvasTexture *canvas_texture = nullptr;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
void copy_from(const Texture &o) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
proxy_to = o.proxy_to;
is_proxy = o.is_proxy;
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
is_external = o.is_external;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
width = o.width;
height = o.height;
alloc_width = o.alloc_width;
alloc_height = o.alloc_height;
format = o.format;
type = o.type;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
layered_type = o.layered_type;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
target = o.target;
total_data_size = o.total_data_size;
compressed = o.compressed;
mipmaps = o.mipmaps;
resize_to_po2 = o.resize_to_po2;
active = o.active;
tex_id = o.tex_id;
stored_cube_sides = o.stored_cube_sides;
render_target = o.render_target;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
is_render_target = o.is_render_target;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
redraw_if_visible = o.redraw_if_visible;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
detect_3d_callback = o.detect_3d_callback;
detect_3d_callback_ud = o.detect_3d_callback_ud;
detect_normal_callback = o.detect_normal_callback;
detect_normal_callback_ud = o.detect_normal_callback_ud;
detect_roughness_callback = o.detect_roughness_callback;
detect_roughness_callback_ud = o.detect_roughness_callback_ud;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
}
// texture state
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
void gl_set_filter(RS::CanvasItemTextureFilter p_filter) {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
if (p_filter == state_filter) {
return;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Config *config = Config::get_singleton();
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
state_filter = p_filter;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
GLenum pmin = GL_NEAREST;
GLenum pmag = GL_NEAREST;
GLint max_lod = 0;
GLfloat anisotropy = 1.0f;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
switch (state_filter) {
case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST: {
pmin = GL_NEAREST;
pmag = GL_NEAREST;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
max_lod = 0;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
} break;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR: {
pmin = GL_LINEAR;
pmag = GL_LINEAR;
max_lod = 0;
} break;
case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC: {
GLES3: reset anisotropic filtering when changing texture filtering mode
2023-07-17 07:18:39 +02:00
anisotropy = config->anisotropic_level;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
};
[[fallthrough]];
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS: {
pmag = GL_NEAREST;
Add basic lighting to GLES3 renderer. This includes all three light types and IBL, but does not include shadows or any form of GI
2022-05-16 20:56:03 +02:00
if (mipmaps <= 1) {
pmin = GL_NEAREST;
max_lod = 0;
} else if (config->use_nearest_mip_filter) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
pmin = GL_NEAREST_MIPMAP_NEAREST;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
max_lod = 1000;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
} else {
pmin = GL_NEAREST_MIPMAP_LINEAR;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
max_lod = 1000;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
}
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
} break;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC: {
GLES3: reset anisotropic filtering when changing texture filtering mode
2023-07-17 07:18:39 +02:00
anisotropy = config->anisotropic_level;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
};
[[fallthrough]];
case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS: {
pmag = GL_LINEAR;
Add basic lighting to GLES3 renderer. This includes all three light types and IBL, but does not include shadows or any form of GI
2022-05-16 20:56:03 +02:00
if (mipmaps <= 1) {
pmin = GL_LINEAR;
max_lod = 0;
} else if (config->use_nearest_mip_filter) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
pmin = GL_LINEAR_MIPMAP_NEAREST;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
max_lod = 1000;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
} else {
pmin = GL_LINEAR_MIPMAP_LINEAR;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
max_lod = 1000;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
}
} break;
default: {
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
return;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
} break;
}
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, pmin);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, pmag);
glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, max_lod);
GLES3: reset anisotropic filtering when changing texture filtering mode
2023-07-17 07:18:39 +02:00
if (config->support_anisotropic_filter) {
glTexParameterf(target, _GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
}
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
void gl_set_repeat(RS::CanvasItemTextureRepeat p_repeat) {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
if (p_repeat == state_repeat) {
return;
}
state_repeat = p_repeat;
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
GLenum prep = GL_CLAMP_TO_EDGE;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
switch (state_repeat) {
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
case RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED: {
prep = GL_CLAMP_TO_EDGE;
} break;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
case RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED: {
prep = GL_REPEAT;
} break;
case RS::CANVAS_ITEM_TEXTURE_REPEAT_MIRROR: {
prep = GL_MIRRORED_REPEAT;
} break;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
default: {
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
return;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
} break;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
glTexParameteri(target, GL_TEXTURE_WRAP_T, prep);
glTexParameteri(target, GL_TEXTURE_WRAP_R, prep);
glTexParameteri(target, GL_TEXTURE_WRAP_S, prep);
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
}
private:
GLES3: Don't call glTexParameter* for invalid filter and repeat modes
2023-07-20 07:40:17 +02:00
RS::CanvasItemTextureFilter state_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_MAX;
RS::CanvasItemTextureRepeat state_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_MAX;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
};
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
struct RenderTarget {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Point2i position = Point2i(0, 0);
Size2i size = Size2i(0, 0);
Add multiview to the opengl3 driver
2022-09-04 16:56:24 +02:00
uint32_t view_count = 1;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
int mipmap_count = 1;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
RID self;
GLuint fbo = 0;
GLuint color = 0;
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
GLuint depth = 0;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
GLuint backbuffer_fbo = 0;
GLuint backbuffer = 0;
Incorporating the availability of screen and depth textures for the GLES3 backend
2023-02-01 10:59:56 +01:00
GLuint backbuffer_depth = 0;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
GLuint color_internal_format = GL_RGBA8;
GLuint color_format = GL_RGBA;
GLuint color_type = GL_UNSIGNED_BYTE;
Image::Format image_format = Image::FORMAT_RGBA8;
Add 2D shadows and canvas SDF to OpenGL3 renderer This is an initial implementation based on the current RD implementation Performance will improve later
2022-10-19 02:59:31 +02:00
GLuint sdf_texture_write = 0;
GLuint sdf_texture_write_fb = 0;
GLuint sdf_texture_process[2] = { 0, 0 };
GLuint sdf_texture_read = 0;
RS::ViewportSDFOversize sdf_oversize = RS::VIEWPORT_SDF_OVERSIZE_120_PERCENT;
RS::ViewportSDFScale sdf_scale = RS::VIEWPORT_SDF_SCALE_50_PERCENT;
Size2i process_size;
bool sdf_enabled = false;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
bool is_transparent = false;
bool direct_to_screen = false;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
bool used_in_frame = false;
RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;
Add MSAA support for WebXR
2023-11-08 21:54:29 +01:00
bool reattach_textures = false;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
struct RTOverridden {
bool is_overridden = false;
RID color;
RID depth;
RID velocity;
struct FBOCacheEntry {
GLuint fbo;
Get WebXR fully working in Godot 4!
2022-11-19 03:43:11 +01:00
GLuint color;
GLuint depth;
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
Size2i size;
Vector<GLuint> allocated_textures;
};
RBMap<uint32_t, FBOCacheEntry> fbo_cache;
} overridden;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID texture;
Color clear_color = Color(1, 1, 1, 1);
bool clear_requested = false;
RenderTarget() {
}
};
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
class TextureStorage : public RendererTextureStorage {
private:
static TextureStorage *singleton;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
RID default_gl_textures[DEFAULT_GL_TEXTURE_MAX];
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
/* Canvas Texture API */
RID_Owner<CanvasTexture, true> canvas_texture_owner;
/* Texture API */
Make `RID_Owner<Texture>` threadsafe in `TextureStorage` for gles3
2024-02-11 13:12:21 +01:00
// Textures can be created from threads, so this RID_Owner is thread safe.
mutable RID_Owner<Texture, true> texture_owner;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, Image::Format &r_real_format, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool p_force_decompress) const;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Add 2D lights to OpenGL3 canvas renderer This is an initial implementation using the same single-pass approach as the RenderingDevice.
2022-10-13 02:55:01 +02:00
/* TEXTURE ATLAS API */
struct TextureAtlas {
struct Texture {
int users;
Rect2 uv_rect;
};
struct SortItem {
RID texture;
Size2i pixel_size;
Size2i size;
Point2i pos;
bool operator<(const SortItem &p_item) const {
//sort larger to smaller
if (size.height == p_item.size.height) {
return size.width > p_item.size.width;
} else {
return size.height > p_item.size.height;
}
}
};
HashMap<RID, Texture> textures;
bool dirty = true;
GLuint texture = 0;
GLuint framebuffer = 0;
Size2i size;
} texture_atlas;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
/* Render Target API */
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
mutable RID_Owner<RenderTarget> render_target_owner;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
void _clear_render_target(RenderTarget *rt);
void _update_render_target(RenderTarget *rt);
void _create_render_target_backbuffer(RenderTarget *rt);
Add 2D shadows and canvas SDF to OpenGL3 renderer This is an initial implementation based on the current RD implementation Performance will improve later
2022-10-19 02:59:31 +02:00
void _render_target_allocate_sdf(RenderTarget *rt);
void _render_target_clear_sdf(RenderTarget *rt);
Rect2i _render_target_get_sdf_rect(const RenderTarget *rt) const;
OpenGL: Implement 3D Texture support
2023-08-07 10:41:09 +02:00
void _texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer, bool p_initialize);
void _texture_set_3d_data(RID p_texture, const Vector<Ref<Image>> &p_data, bool p_initialize);
void _texture_set_swizzle(Texture *p_texture, Image::Format p_real_format);
Vector<Ref<Image>> _texture_3d_read_framebuffer(Texture *p_texture) const;
Implemented texture_2D_layered_initialize
2023-05-18 17:41:17 +02:00
Add 2D shadows and canvas SDF to OpenGL3 renderer This is an initial implementation based on the current RD implementation Performance will improve later
2022-10-19 02:59:31 +02:00
struct RenderTargetSDF {
CanvasSdfShaderGLES3 shader;
RID shader_version;
} sdf_shader;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
public:
static TextureStorage *get_singleton();
TextureStorage();
virtual ~TextureStorage();
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
_FORCE_INLINE_ RID texture_gl_get_default(DefaultGLTexture p_texture) {
return default_gl_textures[p_texture];
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
/* Canvas Texture API */
CanvasTexture *get_canvas_texture(RID p_rid) { return canvas_texture_owner.get_or_null(p_rid); };
bool owns_canvas_texture(RID p_rid) { return canvas_texture_owner.owns(p_rid); };
virtual RID canvas_texture_allocate() override;
virtual void canvas_texture_initialize(RID p_rid) override;
virtual void canvas_texture_free(RID p_rid) override;
virtual void canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) override;
virtual void canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) override;
virtual void canvas_texture_set_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) override;
virtual void canvas_texture_set_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) override;
/* Texture API */
Add 3D MSAA and scaling support to GLES3
2023-10-26 03:10:38 +02:00
Texture *get_texture(RID p_rid) const {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Texture *texture = texture_owner.get_or_null(p_rid);
if (texture && texture->is_proxy) {
return texture_owner.get_or_null(texture->proxy_to);
}
return texture;
};
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
bool owns_texture(RID p_rid) { return texture_owner.owns(p_rid); };
Add GLES3 infrastructure for lightmap baking in the compatibility backend
2024-01-19 21:39:26 +01:00
void texture_2d_initialize_from_texture(RID p_texture, Texture &p_tex) {
texture_owner.initialize_rid(p_texture, p_tex);
}
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
virtual bool can_create_resources_async() const override;
virtual RID texture_allocate() override;
virtual void texture_free(RID p_rid) override;
virtual void texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) override;
virtual void texture_2d_layered_initialize(RID p_texture, const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) override;
virtual void texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) override;
virtual void texture_proxy_initialize(RID p_texture, RID p_base) override; //all slices, then all the mipmaps, must be coherent
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
RID texture_create_external(Texture::Type p_type, Image::Format p_format, unsigned int p_image, int p_width, int p_height, int p_depth, int p_layers, RS::TextureLayeredType p_layered_type = RS::TEXTURE_LAYERED_2D_ARRAY);
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
virtual void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) override;
OpenGL: Implement 3D Texture support
2023-08-07 10:41:09 +02:00
virtual void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) override;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
virtual void texture_proxy_update(RID p_proxy, RID p_base) override;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
//these two APIs can be used together or in combination with the others.
virtual void texture_2d_placeholder_initialize(RID p_texture) override;
virtual void texture_2d_layered_placeholder_initialize(RID p_texture, RenderingServer::TextureLayeredType p_layered_type) override;
virtual void texture_3d_placeholder_initialize(RID p_texture) override;
virtual Ref<Image> texture_2d_get(RID p_texture) const override;
OpenGL: Implement 3D Texture support
2023-08-07 10:41:09 +02:00
virtual Ref<Image> texture_2d_layer_get(RID p_texture, int p_layer) const override;
virtual Vector<Ref<Image>> texture_3d_get(RID p_texture) const override;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
virtual void texture_replace(RID p_texture, RID p_by_texture) override;
virtual void texture_set_size_override(RID p_texture, int p_width, int p_height) override;
virtual void texture_set_path(RID p_texture, const String &p_path) override;
virtual String texture_get_path(RID p_texture) const override;
virtual void texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
void texture_set_detect_srgb_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata);
virtual void texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
virtual void texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) override;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
virtual void texture_debug_usage(List<RS::TextureInfo> *r_info) override;
virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) override;
virtual Size2 texture_size_with_proxy(RID p_proxy) override;
Add custom texture create function
2023-07-10 14:31:27 +02:00
virtual void texture_rd_initialize(RID p_texture, const RID &p_rd_texture, const RS::TextureLayeredType p_layer_type = RS::TEXTURE_LAYERED_2D_ARRAY) override;
Merge duplicate rd_texture functions
2023-03-10 10:41:55 +01:00
virtual RID texture_get_rd_texture(RID p_texture, bool p_srgb = false) const override;
For GDExternal use, provides access to internal graphics handles for textures
2023-03-10 11:24:25 +01:00
virtual uint64_t texture_get_native_handle(RID p_texture, bool p_srgb = false) const override;
Expose texture_get_rd_texture
2022-11-01 18:50:36 +01:00
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
void texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer = 0);
Add custom texture create function
2023-07-10 14:31:27 +02:00
virtual Image::Format texture_get_format(RID p_texture) const override;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
uint32_t texture_get_texid(RID p_texture) const;
uint32_t texture_get_width(RID p_texture) const;
uint32_t texture_get_height(RID p_texture) const;
uint32_t texture_get_depth(RID p_texture) const;
void texture_bind(RID p_texture, uint32_t p_texture_no);
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Add 2D lights to OpenGL3 canvas renderer This is an initial implementation using the same single-pass approach as the RenderingDevice.
2022-10-13 02:55:01 +02:00
/* TEXTURE ATLAS API */
void update_texture_atlas();
GLuint texture_atlas_get_texture() const;
_FORCE_INLINE_ Rect2 texture_atlas_get_texture_rect(RID p_texture) {
TextureAtlas::Texture *t = texture_atlas.textures.getptr(p_texture);
if (!t) {
return Rect2();
}
return t->uv_rect;
}
void texture_add_to_texture_atlas(RID p_texture);
void texture_remove_from_texture_atlas(RID p_texture);
void texture_atlas_mark_dirty_on_texture(RID p_texture);
void texture_atlas_remove_texture(RID p_texture);
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
/* DECAL API */
virtual RID decal_allocate() override;
virtual void decal_initialize(RID p_rid) override;
virtual void decal_free(RID p_rid) override{};
Replace Extents with Size in VoxelGI, ReflectionProbe, FogVolume, Decal and GPUParticles*3D - Extents are replaced by Size (Size is Extents * 2) - The UI text displays 'Size' - Snapping is adjusted to work with Size - _set and _get handle extents for compatibility Co-authored-by: ator-dev <dominic.codedeveloper@gmail.com>
2022-07-12 09:43:01 +02:00
virtual void decal_set_size(RID p_decal, const Vector3 &p_size) override;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
virtual void decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) override;
virtual void decal_set_emission_energy(RID p_decal, float p_energy) override;
virtual void decal_set_albedo_mix(RID p_decal, float p_mix) override;
virtual void decal_set_modulate(RID p_decal, const Color &p_modulate) override;
virtual void decal_set_cull_mask(RID p_decal, uint32_t p_layers) override;
virtual void decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) override;
virtual void decal_set_fade(RID p_decal, float p_above, float p_below) override;
virtual void decal_set_normal_fade(RID p_decal, float p_fade) override;
virtual AABB decal_get_aabb(RID p_decal) const override;
Implement cull_mask for decals and lights in mobile and compatibility backends
2023-02-06 21:12:47 +01:00
virtual uint32_t decal_get_cull_mask(RID p_decal) const override { return 0; }
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
virtual void texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
virtual void texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
Move cluster builder, sdfgi and gi structures to clustered renderer, move light and probe elements into storage and reorganise our render_scene method.
2022-09-12 11:44:48 +02:00
/* DECAL INSTANCE */
Sort decals and lights based on camera origin Also implement sort_offset for decals Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2023-01-20 04:44:20 +01:00
virtual RID decal_instance_create(RID p_decal) override { return RID(); }
virtual void decal_instance_free(RID p_decal_instance) override {}
virtual void decal_instance_set_transform(RID p_decal, const Transform3D &p_transform) override {}
virtual void decal_instance_set_sorting_offset(RID p_decal_instance, float p_sorting_offset) override {}
Move cluster builder, sdfgi and gi structures to clustered renderer, move light and probe elements into storage and reorganise our render_scene method.
2022-09-12 11:44:48 +02:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
/* RENDER TARGET API */
static GLuint system_fbo;
RenderTarget *get_render_target(RID p_rid) { return render_target_owner.get_or_null(p_rid); };
bool owns_render_target(RID p_rid) { return render_target_owner.owns(p_rid); };
Add 3D MSAA and scaling support to GLES3
2023-10-26 03:10:38 +02:00
void check_backbuffer(RenderTarget *rt, const bool uses_screen_texture, const bool uses_depth_texture);
Incorporating the availability of screen and depth textures for the GLES3 backend
2023-02-01 10:59:56 +01:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
virtual RID render_target_create() override;
virtual void render_target_free(RID p_rid) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
virtual void render_target_set_position(RID p_render_target, int p_x, int p_y) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual Point2i render_target_get_position(RID p_render_target) const override;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
virtual void render_target_set_size(RID p_render_target, int p_width, int p_height, uint32_t p_view_count) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual Size2i render_target_get_size(RID p_render_target) const override;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
virtual void render_target_set_transparent(RID p_render_target, bool p_is_transparent) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual bool render_target_get_transparent(RID p_render_target) const override;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
virtual void render_target_set_direct_to_screen(RID p_render_target, bool p_direct_to_screen) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual bool render_target_get_direct_to_screen(RID p_render_target) const override;
virtual bool render_target_was_used(RID p_render_target) const override;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
void render_target_clear_used(RID p_render_target);
Implement MSAA for 2D [Vulkan only]
2022-08-13 01:02:32 +02:00
virtual void render_target_set_msaa(RID p_render_target, RS::ViewportMSAA p_msaa) override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual RS::ViewportMSAA render_target_get_msaa(RID p_render_target) const override;
Ensure 2D MSAA resolve is performed when 3D content but no 2D content in scene
2023-11-16 03:24:04 +01:00
virtual void render_target_set_msaa_needs_resolve(RID p_render_target, bool p_needs_resolve) override {}
virtual bool render_target_get_msaa_needs_resolve(RID p_render_target) const override { return false; }
virtual void render_target_do_msaa_resolve(RID p_render_target) override {}
Add option to enable HDR rendering in 2D This is needed to allow 2D to fully make use of 3D effects (e.g. glow), and can be used to substantially improve quality of 2D rendering at the cost of performance Additionally, the 2D rendering pipeline is done in linear space (we skip linear_to_srgb conversion in 3D tonemapping) so the entire Viewport can be kept linear. This is necessary for proper HDR screen support in the future.
2023-08-03 14:10:01 +02:00
virtual void render_target_set_use_hdr(RID p_render_target, bool p_use_hdr_2d) override {}
virtual bool render_target_is_using_hdr(RID p_render_target) const override { return false; }
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
// new
void render_target_set_as_unused(RID p_render_target) override {
render_target_clear_used(p_render_target);
}
void render_target_request_clear(RID p_render_target, const Color &p_clear_color) override;
bool render_target_is_clear_requested(RID p_render_target) override;
Color render_target_get_clear_request_color(RID p_render_target) override;
void render_target_disable_clear_request(RID p_render_target) override;
void render_target_do_clear_request(RID p_render_target) override;
Add 3D MSAA and scaling support to GLES3
2023-10-26 03:10:38 +02:00
GLuint render_target_get_fbo(RID p_render_target) const;
GLuint render_target_get_color(RID p_render_target) const;
GLuint render_target_get_depth(RID p_render_target) const;
Add MSAA support for WebXR
2023-11-08 21:54:29 +01:00
void render_target_set_reattach_textures(RID p_render_target, bool p_reattach_textures) const;
bool render_target_is_reattach_textures(RID p_render_target) const;
Add 3D MSAA and scaling support to GLES3
2023-10-26 03:10:38 +02:00
Add 2D shadows and canvas SDF to OpenGL3 renderer This is an initial implementation based on the current RD implementation Performance will improve later
2022-10-19 02:59:31 +02:00
virtual void render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) override;
virtual Rect2i render_target_get_sdf_rect(RID p_render_target) const override;
GLuint render_target_get_sdf_texture(RID p_render_target);
GLuint render_target_get_sdf_framebuffer(RID p_render_target);
void render_target_sdf_process(RID p_render_target);
virtual void render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) override;
bool render_target_is_sdf_enabled(RID p_render_target) const;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 17:04:41 +02:00
void render_target_copy_to_back_buffer(RID p_render_target, const Rect2i &p_region, bool p_gen_mipmaps);
void render_target_clear_back_buffer(RID p_render_target, const Rect2i &p_region, const Color &p_color);
void render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region);
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual void render_target_set_vrs_mode(RID p_render_target, RS::ViewportVRSMode p_mode) override {}
virtual RS::ViewportVRSMode render_target_get_vrs_mode(RID p_render_target) const override { return RS::VIEWPORT_VRS_DISABLED; }
virtual void render_target_set_vrs_texture(RID p_render_target, RID p_texture) override {}
virtual RID render_target_get_vrs_texture(RID p_render_target) const override { return RID(); }
Add support for OpenGL to OpenXR
2022-10-23 03:29:15 +02:00
virtual void render_target_set_override(RID p_render_target, RID p_color_texture, RID p_depth_texture, RID p_velocity_texture) override;
virtual RID render_target_get_override_color(RID p_render_target) const override;
virtual RID render_target_get_override_depth(RID p_render_target) const override;
virtual RID render_target_get_override_velocity(RID p_render_target) const override;
Adding getters to RenderTarget and implementing override functionality for XR
2022-09-01 10:10:53 +02:00
virtual RID render_target_get_texture(RID p_render_target) override;
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 12:33:54 +01:00
void bind_framebuffer(GLuint framebuffer) {
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
}
void bind_framebuffer_system() {
glBindFramebuffer(GL_FRAMEBUFFER, GLES3::TextureStorage::system_fbo);
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
String get_framebuffer_error(GLenum p_status);
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
};
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
inline String TextureStorage::get_framebuffer_error(GLenum p_status) {
[macOS/Windows] Add optional ANGLE backed OpenGL renderer support. Add EGL_ANDROID_blob_cache caching. Co-authored-by: Riteo <riteo@posteo.net>
2021-11-12 13:49:49 +01:00
#if defined(DEBUG_ENABLED) && defined(GL_API_ENABLED)
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-20 01:08:53 +01:00
if (p_status == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT) {
return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
} else if (p_status == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT) {
return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
} else if (p_status == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER) {
return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
} else if (p_status == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER) {
return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
}
#endif
return itos(p_status);
}
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
} // namespace GLES3
Code quality: Fix header guards consistency Adds `header_guards.sh` bash script, used in CI to validate future changes. Can be run locally to fix invalid header guards.
2022-07-23 23:41:51 +02:00
#endif // GLES3_ENABLED
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
Code quality: Fix header guards consistency Adds `header_guards.sh` bash script, used in CI to validate future changes. Can be run locally to fix invalid header guards.
2022-07-23 23:41:51 +02:00
#endif // TEXTURE_STORAGE_GLES3_H
Reference in a new issue Copy permalink