2017-12-04 13:41:34 +01:00
/*************************************************************************/
/* rasterizer_storage_gles2.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2017-12-04 13:41:34 +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-09-11 18:13:45 +02:00
2017-12-04 13:41:34 +01:00
# include "rasterizer_storage_gles2.h"
2018-08-24 09:35:07 +02:00
2018-09-11 18:13:45 +02:00
# include "core/math/transform.h"
# include "core/project_settings.h"
2017-12-04 13:41:34 +01:00
# include "rasterizer_canvas_gles2.h"
# include "rasterizer_scene_gles2.h"
2018-02-24 14:48:22 +01:00
# include "servers/visual/shader_language.h"
2019-03-01 20:12:35 +01:00
2017-12-04 13:41:34 +01:00
GLuint RasterizerStorageGLES2 : : system_fbo = 0 ;
/* TEXTURE API */
2018-02-24 14:48:22 +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
2019-03-01 22:18:55 +01:00
# 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
2018-02-24 14:48:22 +01:00
# define _EXT_ETC1_RGB8_OES 0x8D64
2019-03-01 22:18:55 +01:00
# define _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
# define _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01
# define _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
# define _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
# define _EXT_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT 0x8A54
# define _EXT_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT 0x8A55
# define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT 0x8A56
# define _EXT_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT 0x8A57
# define _EXT_COMPRESSED_RGBA_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
2018-02-24 14:48:22 +01:00
# ifdef GLES_OVER_GL
# define _GL_HALF_FLOAT_OES 0x140B
# else
# define _GL_HALF_FLOAT_OES 0x8D61
# endif
2018-09-23 17:12:30 +02:00
# define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
2018-12-21 14:01:16 +01:00
# define _RED_OES 0x1903
2019-02-27 22:56:47 +01:00
# define _DEPTH_COMPONENT24_OES 0x81A6
2019-04-29 20:51:09 +02:00
# ifndef GLES_OVER_GL
2019-09-01 00:03:55 +02:00
# define glClearDepth glClearDepthf
2019-04-29 20:51:09 +02:00
// enable extensions manually for android and ios
2019-11-26 17:55:19 +01:00
# ifndef UWP_ENABLED
2019-04-29 20:51:09 +02:00
# include <dlfcn.h> // needed to load extensions
2019-11-26 17:55:19 +01:00
# endif
2019-04-29 20:51:09 +02:00
# ifdef IPHONE_ENABLED
# include <OpenGLES/ES2/glext.h>
//void *glRenderbufferStorageMultisampleAPPLE;
//void *glResolveMultisampleFramebufferAPPLE;
# define glRenderbufferStorageMultisample glRenderbufferStorageMultisampleAPPLE
2019-11-26 17:55:19 +01:00
# elif defined(ANDROID_ENABLED)
2019-04-29 20:51:09 +02:00
# include <GLES2/gl2ext.h>
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT ;
PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC glFramebufferTexture2DMultisampleEXT ;
# define glRenderbufferStorageMultisample glRenderbufferStorageMultisampleEXT
# define glFramebufferTexture2DMultisample glFramebufferTexture2DMultisampleEXT
2019-11-26 17:55:19 +01:00
# elif defined(UWP_ENABLED)
# include <GLES2/gl2ext.h>
# define glRenderbufferStorageMultisample glRenderbufferStorageMultisampleANGLE
# define glFramebufferTexture2DMultisample glFramebufferTexture2DMultisampleANGLE
2019-04-29 20:51:09 +02:00
# endif
# define GL_MAX_SAMPLES 0x8D57
# endif //!GLES_OVER_GL
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : bind_quad_array ( ) const {
glBindBuffer ( GL_ARRAY_BUFFER , resources . quadie ) ;
glVertexAttribPointer ( VS : : ARRAY_VERTEX , 2 , GL_FLOAT , GL_FALSE , sizeof ( float ) * 4 , 0 ) ;
2019-02-27 10:07:30 +01:00
glVertexAttribPointer ( VS : : ARRAY_TEX_UV , 2 , GL_FLOAT , GL_FALSE , sizeof ( float ) * 4 , CAST_INT_TO_UCHAR_PTR ( 8 ) ) ;
2018-02-24 14:48:22 +01:00
glEnableVertexAttribArray ( VS : : ARRAY_VERTEX ) ;
glEnableVertexAttribArray ( VS : : ARRAY_TEX_UV ) ;
}
2019-10-25 12:24:17 +02:00
Ref < Image > RasterizerStorageGLES2 : : _get_gl_image_and_format ( const Ref < Image > & p_image , Image : : Format p_format , uint32_t p_flags , 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 {
2017-12-04 13:41:34 +01:00
r_gl_format = 0 ;
Ref < Image > image = p_image ;
2018-02-24 14:48:22 +01:00
r_compressed = false ;
2018-08-22 04:56:04 +02:00
r_real_format = p_format ;
2017-12-04 13:41:34 +01:00
bool need_decompress = false ;
switch ( p_format ) {
case Image : : FORMAT_L8 : {
r_gl_internal_format = GL_LUMINANCE ;
r_gl_format = GL_LUMINANCE ;
r_gl_type = GL_UNSIGNED_BYTE ;
} break ;
case Image : : FORMAT_LA8 : {
r_gl_internal_format = GL_LUMINANCE_ALPHA ;
r_gl_format = GL_LUMINANCE_ALPHA ;
r_gl_type = GL_UNSIGNED_BYTE ;
} break ;
case Image : : FORMAT_R8 : {
r_gl_internal_format = GL_ALPHA ;
r_gl_format = GL_ALPHA ;
r_gl_type = GL_UNSIGNED_BYTE ;
} break ;
case Image : : FORMAT_RG8 : {
2019-03-12 00:32:08 +01:00
ERR_PRINT ( " RG texture not supported, converting to RGB8. " ) ;
if ( image . is_valid ( ) )
image - > convert ( Image : : FORMAT_RGB8 ) ;
r_real_format = Image : : FORMAT_RGB8 ;
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGB8 : {
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
} break ;
case Image : : FORMAT_RGBA8 : {
r_gl_format = GL_RGBA ;
r_gl_internal_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
} break ;
case Image : : FORMAT_RGBA4444 : {
r_gl_internal_format = GL_RGBA ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_SHORT_4_4_4_4 ;
} break ;
case Image : : FORMAT_RGBA5551 : {
r_gl_internal_format = GL_RGB5_A1 ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_SHORT_5_5_5_1 ;
} break ;
case Image : : FORMAT_RF : {
2018-02-24 14:48:22 +01:00
if ( ! config . float_texture_supported ) {
2019-03-12 00:32:08 +01:00
ERR_PRINT ( " R float texture not supported, converting to RGB8. " ) ;
if ( image . is_valid ( ) )
image - > convert ( Image : : FORMAT_RGB8 ) ;
r_real_format = Image : : FORMAT_RGB8 ;
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
} else {
r_gl_internal_format = GL_ALPHA ;
r_gl_format = GL_ALPHA ;
r_gl_type = GL_FLOAT ;
2018-02-24 14:48:22 +01:00
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGF : {
2019-03-12 00:32:08 +01:00
ERR_PRINT ( " RG float texture not supported, converting to RGB8. " ) ;
if ( image . is_valid ( ) )
image - > convert ( Image : : FORMAT_RGB8 ) ;
r_real_format = Image : : FORMAT_RGB8 ;
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGBF : {
2018-02-24 14:48:22 +01:00
if ( ! config . float_texture_supported ) {
2019-03-12 00:32:08 +01:00
ERR_PRINT ( " RGB float texture not supported, converting to RGB8. " ) ;
if ( image . is_valid ( ) )
image - > convert ( Image : : FORMAT_RGB8 ) ;
r_real_format = Image : : FORMAT_RGB8 ;
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
} else {
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_FLOAT ;
2018-02-24 14:48:22 +01:00
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGBAF : {
2018-02-24 14:48:22 +01:00
if ( ! config . float_texture_supported ) {
2019-03-12 00:32:08 +01:00
ERR_PRINT ( " RGBA float texture not supported, converting to RGBA8. " ) ;
if ( image . is_valid ( ) )
image - > convert ( Image : : FORMAT_RGBA8 ) ;
r_real_format = Image : : FORMAT_RGBA8 ;
r_gl_internal_format = GL_RGBA ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
} else {
r_gl_internal_format = GL_RGBA ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_FLOAT ;
2018-02-24 14:48:22 +01:00
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RH : {
2018-02-24 14:48:22 +01:00
need_decompress = true ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGH : {
2018-02-24 14:48:22 +01:00
need_decompress = true ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGBH : {
2018-02-24 14:48:22 +01:00
need_decompress = true ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGBAH : {
2018-02-24 14:48:22 +01:00
need_decompress = true ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGBE9995 : {
2018-02-24 14:48:22 +01:00
r_gl_internal_format = GL_RGB ;
r_gl_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
if ( image . is_valid ( ) )
image = image - > rgbe_to_srgb ( ) ;
return image ;
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_DXT1 : {
2019-10-25 12:24:17 +02:00
if ( config . s3tc_supported ) {
2018-02-24 14:48:22 +01:00
r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
2019-01-26 22:25:03 +01:00
r_compressed = true ;
2018-02-24 14:48:22 +01:00
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_DXT3 : {
2019-10-25 12:24:17 +02:00
if ( config . s3tc_supported ) {
2018-02-24 14:48:22 +01:00
r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_DXT5 : {
2019-10-25 12:24:17 +02:00
if ( config . s3tc_supported ) {
2018-02-24 14:48:22 +01:00
r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGTC_R : {
2019-03-01 22:18:55 +01:00
if ( config . rgtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RED_RGTC1_EXT ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_RGTC_RG : {
2019-03-01 22:18:55 +01:00
if ( config . rgtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_BPTC_RGBA : {
2019-03-01 22:18:55 +01:00
if ( config . bptc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGBA_BPTC_UNORM ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_BPTC_RGBF : {
2019-03-01 22:18:55 +01:00
if ( config . bptc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT ;
r_gl_format = GL_RGB ;
r_gl_type = GL_FLOAT ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_BPTC_RGBFU : {
2019-03-01 22:18:55 +01:00
if ( config . bptc_supported ) {
2017-12-04 13:41:34 +01:00
2019-03-01 22:18:55 +01:00
r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT ;
r_gl_format = GL_RGB ;
r_gl_type = GL_FLOAT ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_PVRTC2 : {
2019-03-01 22:18:55 +01:00
if ( config . pvrtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGB_PVRTC_2BPPV1_IMG ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_PVRTC2A : {
2019-03-01 22:18:55 +01:00
if ( config . pvrtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_PVRTC4 : {
2019-03-01 22:18:55 +01:00
if ( config . pvrtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGB_PVRTC_4BPPV1_IMG ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_PVRTC4A : {
2019-03-01 22:18:55 +01:00
if ( config . pvrtc_supported ) {
r_gl_internal_format = _EXT_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_ETC : {
2019-10-25 12:24:17 +02:00
if ( config . etc1_supported ) {
2018-02-24 14:48:22 +01:00
r_gl_internal_format = _EXT_ETC1_RGB8_OES ;
r_gl_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_compressed = true ;
} else {
need_decompress = true ;
}
2017-12-04 13:41:34 +01:00
} break ;
case Image : : FORMAT_ETC2_R11 : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_R11S : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_RG11 : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_RG11S : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_RGB8 : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_RGBA8 : {
need_decompress = true ;
} break ;
case Image : : FORMAT_ETC2_RGB8A1 : {
need_decompress = true ;
} break ;
default : {
ERR_FAIL_V ( Ref < Image > ( ) ) ;
}
}
2019-10-25 12:24:17 +02:00
if ( need_decompress | | p_force_decompress ) {
2017-12-04 13:41:34 +01:00
if ( ! image . is_null ( ) ) {
2019-02-25 02:34:12 +01:00
2017-12-04 13:41:34 +01:00
image = image - > duplicate ( ) ;
image - > decompress ( ) ;
ERR_FAIL_COND_V ( image - > is_compressed ( ) , image ) ;
2019-02-25 02:34:12 +01:00
switch ( image - > get_format ( ) ) {
case Image : : FORMAT_RGB8 : {
r_gl_format = GL_RGB ;
r_gl_internal_format = GL_RGB ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_real_format = Image : : FORMAT_RGB8 ;
r_compressed = false ;
} break ;
case Image : : FORMAT_RGBA8 : {
r_gl_format = GL_RGBA ;
r_gl_internal_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_real_format = Image : : FORMAT_RGBA8 ;
r_compressed = false ;
} break ;
default : {
image - > convert ( Image : : FORMAT_RGBA8 ) ;
r_gl_format = GL_RGBA ;
r_gl_internal_format = GL_RGBA ;
r_gl_type = GL_UNSIGNED_BYTE ;
r_real_format = Image : : FORMAT_RGBA8 ;
r_compressed = false ;
} break ;
}
2017-12-04 13:41:34 +01:00
}
return image ;
}
return p_image ;
}
static const GLenum _cube_side_enum [ 6 ] = {
GL_TEXTURE_CUBE_MAP_NEGATIVE_X ,
GL_TEXTURE_CUBE_MAP_POSITIVE_X ,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y ,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z ,
} ;
RID RasterizerStorageGLES2 : : texture_create ( ) {
Texture * texture = memnew ( Texture ) ;
ERR_FAIL_COND_V ( ! texture , RID ( ) ) ;
glGenTextures ( 1 , & texture - > tex_id ) ;
texture - > active = false ;
texture - > total_data_size = 0 ;
return texture_owner . make_rid ( texture ) ;
}
2018-06-26 13:59:26 +02:00
void RasterizerStorageGLES2 : : texture_allocate ( RID p_texture , int p_width , int p_height , int p_depth_3d , Image : : Format p_format , VisualServer : : TextureType p_type , uint32_t p_flags ) {
2017-12-04 13:41:34 +01:00
GLenum format ;
GLenum internal_format ;
GLenum type ;
2018-02-24 14:48:22 +01:00
bool compressed = false ;
2017-12-04 13:41:34 +01:00
if ( p_flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) {
p_flags & = ~ VS : : TEXTURE_FLAG_MIPMAPS ; // no mipies for video
}
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > width = p_width ;
texture - > height = p_height ;
texture - > format = p_format ;
texture - > flags = p_flags ;
texture - > stored_cube_sides = 0 ;
2018-06-26 13:59:26 +02:00
texture - > type = p_type ;
switch ( p_type ) {
case VS : : TEXTURE_TYPE_2D : {
texture - > target = GL_TEXTURE_2D ;
2018-08-06 19:56:06 +02:00
texture - > images . resize ( 1 ) ;
2018-06-26 13:59:26 +02:00
} break ;
case VS : : TEXTURE_TYPE_CUBEMAP : {
texture - > target = GL_TEXTURE_CUBE_MAP ;
2018-08-06 19:56:06 +02:00
texture - > images . resize ( 6 ) ;
2018-06-26 13:59:26 +02:00
} break ;
case VS : : TEXTURE_TYPE_2D_ARRAY : {
2018-08-06 19:56:06 +02:00
texture - > images . resize ( p_depth_3d ) ;
2018-06-26 13:59:26 +02:00
} break ;
case VS : : TEXTURE_TYPE_3D : {
2018-08-06 19:56:06 +02:00
texture - > images . resize ( p_depth_3d ) ;
2018-06-26 13:59:26 +02:00
} break ;
2018-08-22 18:20:18 +02:00
default : {
ERR_PRINT ( " Unknown texture type! " ) ;
return ;
}
2018-06-26 13:59:26 +02:00
}
2017-12-04 13:41:34 +01:00
texture - > alloc_width = texture - > width ;
texture - > alloc_height = texture - > height ;
2019-02-25 02:34:12 +01:00
texture - > resize_to_po2 = false ;
if ( ! config . support_npot_repeat_mipmap ) {
int po2_width = next_power_of_2 ( p_width ) ;
int po2_height = next_power_of_2 ( p_height ) ;
bool is_po2 = p_width = = po2_width & & p_height = = po2_height ;
if ( ! is_po2 & & ( p_flags & VS : : TEXTURE_FLAG_REPEAT | | p_flags & VS : : TEXTURE_FLAG_MIPMAPS ) ) {
if ( p_flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) {
//not supported
ERR_PRINTS ( " Streaming texture for non power of 2 or has mipmaps on this hardware: " + texture - > path + " '. Mipmaps and repeat disabled. " ) ;
texture - > flags & = ~ ( VS : : TEXTURE_FLAG_REPEAT | VS : : TEXTURE_FLAG_MIPMAPS ) ;
} else {
texture - > alloc_height = po2_height ;
texture - > alloc_width = po2_width ;
texture - > resize_to_po2 = true ;
}
}
}
Image : : Format real_format ;
_get_gl_image_and_format ( Ref < Image > ( ) , texture - > format , texture - > flags , real_format , format , internal_format , type , compressed , texture - > resize_to_po2 ) ;
2017-12-04 13:41:34 +01:00
texture - > gl_format_cache = format ;
texture - > gl_type_cache = type ;
texture - > gl_internal_format_cache = internal_format ;
texture - > data_size = 0 ;
texture - > mipmaps = 1 ;
2018-02-24 14:48:22 +01:00
texture - > compressed = compressed ;
2017-12-04 13:41:34 +01:00
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
if ( p_flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) {
//prealloc if video
2019-02-25 02:34:12 +01:00
glTexImage2D ( texture - > target , 0 , internal_format , texture - > alloc_width , texture - > alloc_height , 0 , format , type , NULL ) ;
2017-12-04 13:41:34 +01:00
}
texture - > active = true ;
}
2018-06-26 13:59:26 +02:00
void RasterizerStorageGLES2 : : texture_set_data ( RID p_texture , const Ref < Image > & p_image , int p_layer ) {
2017-12-04 13:41:34 +01:00
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
ERR_FAIL_COND ( ! texture - > active ) ;
ERR_FAIL_COND ( texture - > render_target ) ;
ERR_FAIL_COND ( texture - > format ! = p_image - > get_format ( ) ) ;
ERR_FAIL_COND ( p_image . is_null ( ) ) ;
GLenum type ;
GLenum format ;
GLenum internal_format ;
bool compressed = false ;
if ( config . keep_original_textures & & ! ( texture - > flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) ) {
2018-08-06 19:56:06 +02:00
texture - > images . write [ p_layer ] = p_image ;
2017-12-04 13:41:34 +01:00
}
2018-08-22 04:56:04 +02:00
Image : : Format real_format ;
2019-02-25 02:34:12 +01:00
Ref < Image > img = _get_gl_image_and_format ( p_image , p_image - > get_format ( ) , texture - > flags , real_format , format , internal_format , type , compressed , texture - > resize_to_po2 ) ;
if ( texture - > resize_to_po2 ) {
if ( p_image - > is_compressed ( ) ) {
2019-10-27 00:28:54 +02:00
ERR_PRINTS ( " Texture ' " + texture - > path + " ' is required to be a power of 2 because it uses either mipmaps or repeat, so it was decompressed. This will hurt performance and memory usage. " ) ;
2019-02-25 02:34:12 +01:00
}
if ( img = = p_image ) {
img = img - > duplicate ( ) ;
}
img - > resize_to_po2 ( false ) ;
}
2017-12-04 13:41:34 +01:00
if ( config . shrink_textures_x2 & & ( p_image - > has_mipmaps ( ) | | ! p_image - > is_compressed ( ) ) & & ! ( texture - > flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) ) {
texture - > alloc_height = MAX ( 1 , texture - > alloc_height / 2 ) ;
texture - > alloc_width = MAX ( 1 , texture - > alloc_width / 2 ) ;
if ( texture - > alloc_width = = img - > get_width ( ) / 2 & & texture - > alloc_height = = img - > get_height ( ) / 2 ) {
img - > shrink_x2 ( ) ;
} else if ( img - > get_format ( ) < = Image : : FORMAT_RGBA8 ) {
img - > resize ( texture - > alloc_width , texture - > alloc_height , Image : : INTERPOLATE_BILINEAR ) ;
}
2019-10-27 00:28:54 +02:00
}
2017-12-04 13:41:34 +01:00
2018-06-26 13:59:26 +02:00
GLenum blit_target = ( texture - > target = = GL_TEXTURE_CUBE_MAP ) ? _cube_side_enum [ p_layer ] : GL_TEXTURE_2D ;
2017-12-04 13:41:34 +01:00
texture - > data_size = img - > get_data ( ) . size ( ) ;
PoolVector < uint8_t > : : Read read = img - > get_data ( ) . read ( ) ;
2019-10-28 08:07:29 +01:00
ERR_FAIL_COND ( ! read . ptr ( ) ) ;
2017-12-04 13:41:34 +01:00
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
texture - > ignore_mipmaps = compressed & & ! img - > has_mipmaps ( ) ;
if ( ( texture - > flags & VS : : TEXTURE_FLAG_MIPMAPS ) & & ! texture - > ignore_mipmaps )
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , config . use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR ) ;
else {
if ( texture - > flags & VS : : TEXTURE_FLAG_FILTER ) {
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
} else {
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
}
}
if ( texture - > flags & VS : : TEXTURE_FLAG_FILTER ) {
glTexParameteri ( texture - > target , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ; // Linear Filtering
} else {
glTexParameteri ( texture - > target , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ; // raw Filtering
}
if ( ( ( texture - > flags & VS : : TEXTURE_FLAG_REPEAT ) | | ( texture - > flags & VS : : TEXTURE_FLAG_MIRRORED_REPEAT ) ) & & texture - > target ! = GL_TEXTURE_CUBE_MAP ) {
if ( texture - > flags & VS : : TEXTURE_FLAG_MIRRORED_REPEAT ) {
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_MIRRORED_REPEAT ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_MIRRORED_REPEAT ) ;
} else {
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_REPEAT ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_REPEAT ) ;
}
} else {
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
glTexParameterf ( texture - > target , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( texture - > target , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
}
int mipmaps = ( ( texture - > flags & VS : : TEXTURE_FLAG_MIPMAPS ) & & img - > has_mipmaps ( ) ) ? img - > get_mipmap_count ( ) + 1 : 1 ;
int w = img - > get_width ( ) ;
int h = img - > get_height ( ) ;
int tsize = 0 ;
for ( int i = 0 ; i < mipmaps ; i + + ) {
int size , ofs ;
img - > get_mipmap_offset_and_size ( i , ofs , size ) ;
2019-10-27 00:28:54 +02:00
if ( compressed ) {
2018-02-24 14:48:22 +01:00
glPixelStorei ( GL_UNPACK_ALIGNMENT , 4 ) ;
int bw = w ;
int bh = h ;
glCompressedTexImage2D ( blit_target , i , internal_format , bw , bh , 0 , size , & read [ ofs ] ) ;
2017-12-04 13:41:34 +01:00
} else {
2018-02-24 14:48:22 +01:00
glPixelStorei ( GL_UNPACK_ALIGNMENT , 1 ) ;
if ( texture - > flags & VS : : TEXTURE_FLAG_USED_FOR_STREAMING ) {
glTexSubImage2D ( blit_target , i , 0 , 0 , w , h , format , type , & read [ ofs ] ) ;
} else {
glTexImage2D ( blit_target , i , internal_format , w , h , 0 , format , type , & read [ ofs ] ) ;
}
2017-12-04 13:41:34 +01:00
}
tsize + = size ;
w = MAX ( 1 , w > > 1 ) ;
h = MAX ( 1 , h > > 1 ) ;
}
info . texture_mem - = texture - > total_data_size ;
texture - > total_data_size = tsize ;
info . texture_mem + = texture - > total_data_size ;
// printf("texture: %i x %i - size: %i - total: %i\n", texture->width, texture->height, tsize, info.texture_mem);
2018-06-26 13:59:26 +02:00
texture - > stored_cube_sides | = ( 1 < < p_layer ) ;
2017-12-04 13:41:34 +01:00
2018-06-26 13:59:26 +02:00
if ( ( texture - > flags & VS : : TEXTURE_FLAG_MIPMAPS ) & & mipmaps = = 1 & & ! texture - > ignore_mipmaps & & ( texture - > type ! = VS : : TEXTURE_TYPE_CUBEMAP | | texture - > stored_cube_sides = = ( 1 < < 6 ) - 1 ) ) {
2017-12-04 13:41:34 +01:00
//generate mipmaps if they were requested and the image does not contain them
glGenerateMipmap ( texture - > target ) ;
}
texture - > mipmaps = mipmaps ;
}
2018-06-26 13:59:26 +02:00
void RasterizerStorageGLES2 : : texture_set_data_partial ( RID p_texture , const Ref < Image > & p_image , int src_x , int src_y , int src_w , int src_h , int dst_x , int dst_y , int p_dst_mip , int p_layer ) {
2018-04-29 01:23:55 +02:00
// TODO
ERR_PRINT ( " Not implemented (ask Karroffel to do it :p) " ) ;
}
2018-06-26 13:59:26 +02:00
Ref < Image > RasterizerStorageGLES2 : : texture_get_data ( RID p_texture , int p_layer ) const {
2017-12-04 13:41:34 +01:00
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , Ref < Image > ( ) ) ;
ERR_FAIL_COND_V ( ! texture - > active , Ref < Image > ( ) ) ;
ERR_FAIL_COND_V ( texture - > data_size = = 0 & & ! texture - > render_target , Ref < Image > ( ) ) ;
2018-08-06 18:26:17 +02:00
if ( texture - > type = = VS : : TEXTURE_TYPE_CUBEMAP & & p_layer < 6 & & p_layer > = 0 & & ! texture - > images [ p_layer ] . is_null ( ) ) {
2018-06-26 13:59:26 +02:00
return texture - > images [ p_layer ] ;
2017-12-04 13:41:34 +01:00
}
2018-08-22 04:56:04 +02:00
2017-12-04 13:41:34 +01:00
# ifdef GLES_OVER_GL
2018-08-22 04:56:04 +02:00
Image : : Format real_format ;
GLenum gl_format ;
GLenum gl_internal_format ;
GLenum gl_type ;
bool compressed ;
2019-02-25 02:34:12 +01:00
_get_gl_image_and_format ( Ref < Image > ( ) , texture - > format , texture - > flags , real_format , gl_format , gl_internal_format , gl_type , compressed , false ) ;
2018-08-22 04:56:04 +02:00
2017-12-04 13:41:34 +01:00
PoolVector < uint8_t > data ;
2018-09-29 01:32:40 +02:00
int data_size = Image : : get_image_data_size ( texture - > alloc_width , texture - > alloc_height , real_format , texture - > mipmaps > 1 ) ;
2017-12-04 13:41:34 +01:00
data . resize ( data_size * 2 ) ; //add some memory at the end, just in case for buggy drivers
PoolVector < uint8_t > : : Write wb = data . write ( ) ;
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
glBindBuffer ( GL_PIXEL_PACK_BUFFER , 0 ) ;
for ( int i = 0 ; i < texture - > mipmaps ; i + + ) {
2019-05-08 17:20:42 +02:00
int ofs = Image : : get_image_mipmap_offset ( texture - > alloc_width , texture - > alloc_height , real_format , i ) ;
2017-12-04 13:41:34 +01:00
2018-08-06 18:26:17 +02:00
if ( texture - > compressed ) {
glPixelStorei ( GL_PACK_ALIGNMENT , 4 ) ;
glGetCompressedTexImage ( texture - > target , i , & wb [ ofs ] ) ;
} else {
glPixelStorei ( GL_PACK_ALIGNMENT , 1 ) ;
glGetTexImage ( texture - > target , i , texture - > gl_format_cache , texture - > gl_type_cache , & wb [ ofs ] ) ;
}
2017-12-04 13:41:34 +01:00
}
2019-07-05 19:08:43 +02:00
wb . release ( ) ;
2017-12-04 13:41:34 +01:00
2018-08-27 15:12:07 +02:00
data . resize ( data_size ) ;
2017-12-04 13:41:34 +01:00
2019-06-26 15:08:25 +02:00
Image * img = memnew ( Image ( texture - > alloc_width , texture - > alloc_height , texture - > mipmaps > 1 , real_format , data ) ) ;
2017-12-04 13:41:34 +01:00
return Ref < Image > ( img ) ;
# else
2018-10-18 11:52:08 +02:00
Image : : Format real_format ;
GLenum gl_format ;
GLenum gl_internal_format ;
GLenum gl_type ;
bool compressed ;
2019-02-25 02:34:12 +01:00
_get_gl_image_and_format ( Ref < Image > ( ) , texture - > format , texture - > flags , real_format , gl_format , gl_internal_format , gl_type , compressed , texture - > resize_to_po2 ) ;
2018-10-18 11:52:08 +02:00
PoolVector < uint8_t > data ;
int data_size = Image : : get_image_data_size ( texture - > alloc_width , texture - > alloc_height , Image : : FORMAT_RGBA8 , false ) ;
data . resize ( data_size * 2 ) ; //add some memory at the end, just in case for buggy drivers
PoolVector < uint8_t > : : Write wb = data . write ( ) ;
GLuint temp_framebuffer ;
glGenFramebuffers ( 1 , & temp_framebuffer ) ;
GLuint temp_color_texture ;
glGenTextures ( 1 , & temp_color_texture ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , temp_framebuffer ) ;
glBindTexture ( GL_TEXTURE_2D , temp_color_texture ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , texture - > alloc_width , texture - > alloc_height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , NULL ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , temp_color_texture , 0 ) ;
glDepthMask ( GL_FALSE ) ;
glDisable ( GL_DEPTH_TEST ) ;
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_BLEND ) ;
glDepthFunc ( GL_LEQUAL ) ;
glColorMask ( 1 , 1 , 1 , 1 ) ;
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , texture - > tex_id ) ;
glViewport ( 0 , 0 , texture - > alloc_width , texture - > alloc_height ) ;
shaders . copy . bind ( ) ;
glClearColor ( 0.0 , 0.0 , 0.0 , 0.0 ) ;
glClear ( GL_COLOR_BUFFER_BIT ) ;
bind_quad_array ( ) ;
glDrawArrays ( GL_TRIANGLE_FAN , 0 , 4 ) ;
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
glReadPixels ( 0 , 0 , texture - > alloc_width , texture - > alloc_height , GL_RGBA , GL_UNSIGNED_BYTE , & wb [ 0 ] ) ;
glDeleteTextures ( 1 , & temp_color_texture ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , 0 ) ;
glDeleteFramebuffers ( 1 , & temp_framebuffer ) ;
2019-07-05 19:08:43 +02:00
wb . release ( ) ;
2018-10-18 11:52:08 +02:00
data . resize ( data_size ) ;
Image * img = memnew ( Image ( texture - > alloc_width , texture - > alloc_height , false , Image : : FORMAT_RGBA8 , data ) ) ;
if ( ! texture - > compressed ) {
img - > convert ( real_format ) ;
}
return Ref < Image > ( img ) ;
2017-12-04 13:41:34 +01:00
# endif
}
void RasterizerStorageGLES2 : : texture_set_flags ( RID p_texture , uint32_t p_flags ) {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
bool had_mipmaps = texture - > flags & VS : : TEXTURE_FLAG_MIPMAPS ;
2018-08-23 18:25:55 +02:00
texture - > flags = p_flags ;
2017-12-04 13:41:34 +01:00
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
if ( ( ( texture - > flags & VS : : TEXTURE_FLAG_REPEAT ) | | ( texture - > flags & VS : : TEXTURE_FLAG_MIRRORED_REPEAT ) ) & & texture - > target ! = GL_TEXTURE_CUBE_MAP ) {
if ( texture - > flags & VS : : TEXTURE_FLAG_MIRRORED_REPEAT ) {
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_MIRRORED_REPEAT ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_MIRRORED_REPEAT ) ;
} else {
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_REPEAT ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_REPEAT ) ;
}
} else {
//glTexParameterf( texture->target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
glTexParameterf ( texture - > target , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( texture - > target , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
}
if ( ( texture - > flags & VS : : TEXTURE_FLAG_MIPMAPS ) & & ! texture - > ignore_mipmaps ) {
if ( ! had_mipmaps & & texture - > mipmaps = = 1 ) {
glGenerateMipmap ( texture - > target ) ;
}
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , config . use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR ) ;
} else {
if ( texture - > flags & VS : : TEXTURE_FLAG_FILTER ) {
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
} else {
glTexParameteri ( texture - > target , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
}
}
if ( texture - > flags & VS : : TEXTURE_FLAG_FILTER ) {
glTexParameteri ( texture - > target , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ; // Linear Filtering
} else {
glTexParameteri ( texture - > target , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ; // raw Filtering
}
}
uint32_t RasterizerStorageGLES2 : : texture_get_flags ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , 0 ) ;
return texture - > flags ;
}
Image : : Format RasterizerStorageGLES2 : : texture_get_format ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , Image : : FORMAT_L8 ) ;
return texture - > format ;
}
2018-06-26 13:59:26 +02:00
VisualServer : : TextureType RasterizerStorageGLES2 : : texture_get_type ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , VS : : TEXTURE_TYPE_2D ) ;
return texture - > type ;
}
2017-12-04 13:41:34 +01:00
uint32_t RasterizerStorageGLES2 : : texture_get_texid ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , 0 ) ;
return texture - > tex_id ;
}
2017-08-20 16:17:24 +02:00
void RasterizerStorageGLES2 : : texture_bind ( RID p_texture , uint32_t p_texture_no ) {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
glActiveTexture ( GL_TEXTURE0 + p_texture_no ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
}
2017-12-04 13:41:34 +01:00
uint32_t RasterizerStorageGLES2 : : texture_get_width ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , 0 ) ;
return texture - > width ;
}
uint32_t RasterizerStorageGLES2 : : texture_get_height ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , 0 ) ;
return texture - > height ;
}
2018-06-26 13:59:26 +02:00
uint32_t RasterizerStorageGLES2 : : texture_get_depth ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , 0 ) ;
return texture - > depth ;
}
void RasterizerStorageGLES2 : : texture_set_size_override ( RID p_texture , int p_width , int p_height , int p_depth ) {
2017-12-04 13:41:34 +01:00
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
ERR_FAIL_COND ( texture - > render_target ) ;
ERR_FAIL_COND ( p_width < = 0 | | p_width > 16384 ) ;
ERR_FAIL_COND ( p_height < = 0 | | p_height > 16384 ) ;
//real texture size is in alloc width and height
texture - > width = p_width ;
texture - > height = p_height ;
}
void RasterizerStorageGLES2 : : texture_set_path ( RID p_texture , const String & p_path ) {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > path = p_path ;
}
String RasterizerStorageGLES2 : : texture_get_path ( RID p_texture ) const {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , " " ) ;
return texture - > path ;
}
void RasterizerStorageGLES2 : : texture_debug_usage ( List < VS : : TextureInfo > * r_info ) {
List < RID > textures ;
texture_owner . get_owned_list ( & textures ) ;
for ( List < RID > : : Element * E = textures . front ( ) ; E ; E = E - > next ( ) ) {
Texture * t = texture_owner . getornull ( E - > get ( ) ) ;
if ( ! t )
continue ;
VS : : TextureInfo tinfo ;
tinfo . path = t - > path ;
tinfo . format = t - > format ;
2018-06-26 13:59:26 +02:00
tinfo . width = t - > alloc_width ;
tinfo . height = t - > alloc_height ;
2018-08-27 15:12:07 +02:00
tinfo . depth = 0 ;
2017-12-04 13:41:34 +01:00
tinfo . bytes = t - > total_data_size ;
r_info - > push_back ( tinfo ) ;
}
}
void RasterizerStorageGLES2 : : texture_set_shrink_all_x2_on_set_data ( bool p_enable ) {
config . shrink_textures_x2 = p_enable ;
}
void RasterizerStorageGLES2 : : textures_keep_original ( bool p_enable ) {
config . keep_original_textures = p_enable ;
}
2019-01-27 20:57:05 +01:00
Size2 RasterizerStorageGLES2 : : texture_size_with_proxy ( RID p_texture ) const {
const Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND_V ( ! texture , Size2 ( ) ) ;
if ( texture - > proxy ) {
return Size2 ( texture - > proxy - > width , texture - > proxy - > height ) ;
} else {
return Size2 ( texture - > width , texture - > height ) ;
}
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : texture_set_proxy ( RID p_texture , RID p_proxy ) {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
if ( texture - > proxy ) {
texture - > proxy - > proxy_owners . erase ( texture ) ;
texture - > proxy = NULL ;
}
if ( p_proxy . is_valid ( ) ) {
Texture * proxy = texture_owner . get ( p_proxy ) ;
ERR_FAIL_COND ( ! proxy ) ;
ERR_FAIL_COND ( proxy = = texture ) ;
proxy - > proxy_owners . insert ( texture ) ;
texture - > proxy = proxy ;
}
}
2018-07-16 16:43:26 +02:00
void RasterizerStorageGLES2 : : texture_set_force_redraw_if_visible ( RID p_texture , bool p_enable ) {
Texture * texture = texture_owner . getornull ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > redraw_if_visible = p_enable ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : texture_set_detect_3d_callback ( RID p_texture , VisualServer : : TextureDetectCallback p_callback , void * p_userdata ) {
2018-02-24 14:48:22 +01:00
Texture * texture = texture_owner . get ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > detect_3d = p_callback ;
texture - > detect_3d_ud = p_userdata ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : texture_set_detect_srgb_callback ( RID p_texture , VisualServer : : TextureDetectCallback p_callback , void * p_userdata ) {
2018-02-24 14:48:22 +01:00
Texture * texture = texture_owner . get ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > detect_srgb = p_callback ;
texture - > detect_srgb_ud = p_userdata ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : texture_set_detect_normal_callback ( RID p_texture , VisualServer : : TextureDetectCallback p_callback , void * p_userdata ) {
2018-02-24 14:48:22 +01:00
Texture * texture = texture_owner . get ( p_texture ) ;
ERR_FAIL_COND ( ! texture ) ;
texture - > detect_normal = p_callback ;
texture - > detect_normal_ud = p_userdata ;
2017-12-04 13:41:34 +01:00
}
RID RasterizerStorageGLES2 : : texture_create_radiance_cubemap ( RID p_source , int p_resolution ) const {
2018-02-24 14:48:22 +01:00
2017-12-04 13:41:34 +01:00
return RID ( ) ;
}
RID RasterizerStorageGLES2 : : sky_create ( ) {
2018-02-24 14:48:22 +01:00
Sky * sky = memnew ( Sky ) ;
sky - > radiance = 0 ;
return sky_owner . make_rid ( sky ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : sky_set_texture ( RID p_sky , RID p_panorama , int p_radiance_size ) {
2018-02-24 14:48:22 +01:00
Sky * sky = sky_owner . getornull ( p_sky ) ;
ERR_FAIL_COND ( ! sky ) ;
if ( sky - > panorama . is_valid ( ) ) {
sky - > panorama = RID ( ) ;
glDeleteTextures ( 1 , & sky - > radiance ) ;
sky - > radiance = 0 ;
}
sky - > panorama = p_panorama ;
if ( ! sky - > panorama . is_valid ( ) ) {
return ; // the panorama was cleared
}
Texture * texture = texture_owner . getornull ( sky - > panorama ) ;
if ( ! texture ) {
sky - > panorama = RID ( ) ;
ERR_FAIL_COND ( ! texture ) ;
}
// glBindVertexArray(0) and more
{
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , 0 ) ;
glDisable ( GL_CULL_FACE ) ;
glDisable ( GL_DEPTH_TEST ) ;
glDisable ( GL_SCISSOR_TEST ) ;
glDisable ( GL_BLEND ) ;
for ( int i = 0 ; i < VS : : ARRAY_MAX - 1 ; i + + ) {
glDisableVertexAttribArray ( i ) ;
}
}
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( texture - > target , texture - > tex_id ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ; //need this for proper sampling
glActiveTexture ( GL_TEXTURE1 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . radical_inverse_vdc_cache_tex ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
// New cubemap that will hold the mipmaps with different roughness values
glActiveTexture ( GL_TEXTURE2 ) ;
glGenTextures ( 1 , & sky - > radiance ) ;
glBindTexture ( GL_TEXTURE_CUBE_MAP , sky - > radiance ) ;
2019-03-11 06:05:20 +01:00
int size = p_radiance_size / 2 ; //divide by two because its a cubemap (this is an approximation because GLES3 uses a dual paraboloid)
2018-02-24 14:48:22 +01:00
2018-10-02 14:59:25 +02:00
GLenum internal_format = GL_RGB ;
GLenum format = GL_RGB ;
GLenum type = GL_UNSIGNED_BYTE ;
2018-02-24 14:48:22 +01:00
// Set the initial (empty) mipmaps
2018-10-02 14:59:25 +02:00
# if 1
//Mobile hardware (PowerVR specially) prefers this approach, the other one kills the game
for ( int i = 0 ; i < 6 ; i + + ) {
glTexImage2D ( GL_TEXTURE_CUBE_MAP_POSITIVE_X + i , 0 , internal_format , size , size , 0 , format , type , NULL ) ;
}
glGenerateMipmap ( GL_TEXTURE_CUBE_MAP ) ;
2019-02-26 01:46:24 +01:00
//no filters for now
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
2018-10-02 14:59:25 +02:00
# else
2018-02-24 14:48:22 +01:00
while ( size > = 1 ) {
for ( int i = 0 ; i < 6 ; i + + ) {
glTexImage2D ( _cube_side_enum [ i ] , lod , internal_format , size , size , 0 , format , type , NULL ) ;
}
lod + + ;
size > > = 1 ;
}
2018-10-02 14:59:25 +02:00
# endif
//framebuffer
2019-02-26 01:46:24 +01:00
glBindFramebuffer ( GL_FRAMEBUFFER , resources . mipmap_blur_fbo ) ;
2018-02-24 14:48:22 +01:00
2019-02-26 01:46:24 +01:00
int mipmaps = 6 ;
int lod = 0 ;
int mm_level = mipmaps ;
2019-03-11 06:05:20 +01:00
size = p_radiance_size / 2 ;
2019-02-26 01:46:24 +01:00
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_SOURCE_PANORAMA , true ) ;
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_DIRECT_WRITE , true ) ;
shaders . cubemap_filter . bind ( ) ;
2018-02-24 14:48:22 +01:00
2019-02-26 01:46:24 +01:00
// third, render to the framebuffer using separate textures, then copy to mipmaps
2018-02-24 14:48:22 +01:00
while ( size > = 1 ) {
2019-03-07 04:13:18 +01:00
2019-02-26 01:46:24 +01:00
//make framebuffer size the texture size, need to use a separate texture for compatibility
glActiveTexture ( GL_TEXTURE3 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . mipmap_blur_color ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , size , size , 0 , GL_RGB , GL_UNSIGNED_BYTE , NULL ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , resources . mipmap_blur_color , 0 ) ;
2019-03-07 04:13:18 +01:00
2019-02-26 01:46:24 +01:00
if ( lod = = 1 ) {
//bind panorama for smaller lods
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_CUBE_MAP , sky - > radiance ) ;
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_SOURCE_PANORAMA , false ) ;
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_DIRECT_WRITE , false ) ;
shaders . cubemap_filter . bind ( ) ;
}
glViewport ( 0 , 0 , size , size ) ;
bind_quad_array ( ) ;
2018-02-24 14:48:22 +01:00
2019-02-26 01:46:24 +01:00
glActiveTexture ( GL_TEXTURE2 ) ; //back to panorama
2018-02-24 14:48:22 +01:00
2019-02-26 01:46:24 +01:00
for ( int i = 0 ; i < 6 ; i + + ) {
2018-02-24 14:48:22 +01:00
shaders . cubemap_filter . set_uniform ( CubemapFilterShaderGLES2 : : FACE_ID , i ) ;
2019-02-26 01:46:24 +01:00
float roughness = mm_level > = 0 ? lod / ( float ) ( mipmaps - 1 ) : 1 ;
2018-09-30 04:47:24 +02:00
roughness = MIN ( 1.0 , roughness ) ; //keep max at 1
2018-02-24 14:48:22 +01:00
shaders . cubemap_filter . set_uniform ( CubemapFilterShaderGLES2 : : ROUGHNESS , roughness ) ;
2019-02-26 01:46:24 +01:00
shaders . cubemap_filter . set_uniform ( CubemapFilterShaderGLES2 : : Z_FLIP , false ) ;
2018-02-24 14:48:22 +01:00
glDrawArrays ( GL_TRIANGLE_FAN , 0 , 4 ) ;
2019-02-26 01:46:24 +01:00
2019-03-07 04:13:18 +01:00
glCopyTexSubImage2D ( _cube_side_enum [ i ] , lod , 0 , 0 , 0 , 0 , size , size ) ;
2018-02-24 14:48:22 +01:00
}
size > > = 1 ;
mm_level - - ;
lod + + ;
}
2019-02-26 01:46:24 +01:00
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_SOURCE_PANORAMA , false ) ;
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : USE_DIRECT_WRITE , false ) ;
2018-02-24 14:48:22 +01:00
// restore ranges
2019-02-26 01:46:24 +01:00
glActiveTexture ( GL_TEXTURE2 ) ; //back to panorama
2018-02-24 14:48:22 +01:00
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MIN_FILTER , GL_LINEAR_MIPMAP_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_CUBE_MAP , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
2019-02-26 01:46:24 +01:00
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glActiveTexture ( GL_TEXTURE3 ) ; //back to panorama
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glActiveTexture ( GL_TEXTURE1 ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
2018-02-24 14:48:22 +01:00
// Framebuffer did its job. thank mr framebuffer
2019-02-26 01:46:24 +01:00
glActiveTexture ( GL_TEXTURE0 ) ; //back to panorama
2018-02-24 14:48:22 +01:00
glBindFramebuffer ( GL_FRAMEBUFFER , RasterizerStorageGLES2 : : system_fbo ) ;
2017-12-04 13:41:34 +01:00
}
/* SHADER API */
RID RasterizerStorageGLES2 : : shader_create ( ) {
Shader * shader = memnew ( Shader ) ;
shader - > mode = VS : : SHADER_SPATIAL ;
shader - > shader = & scene - > state . scene_shader ;
RID rid = shader_owner . make_rid ( shader ) ;
_shader_make_dirty ( shader ) ;
shader - > self = rid ;
return rid ;
}
void RasterizerStorageGLES2 : : _shader_make_dirty ( Shader * p_shader ) {
if ( p_shader - > dirty_list . in_list ( ) )
return ;
_shader_dirty_list . add ( & p_shader - > dirty_list ) ;
}
void RasterizerStorageGLES2 : : shader_set_code ( RID p_shader , const String & p_code ) {
Shader * shader = shader_owner . getornull ( p_shader ) ;
ERR_FAIL_COND ( ! shader ) ;
shader - > code = p_code ;
String mode_string = ShaderLanguage : : get_shader_type ( p_code ) ;
VS : : ShaderMode mode ;
if ( mode_string = = " canvas_item " )
mode = VS : : SHADER_CANVAS_ITEM ;
else if ( mode_string = = " particles " )
mode = VS : : SHADER_PARTICLES ;
else
mode = VS : : SHADER_SPATIAL ;
if ( shader - > custom_code_id & & mode ! = shader - > mode ) {
shader - > shader - > free_custom_shader ( shader - > custom_code_id ) ;
shader - > custom_code_id = 0 ;
}
shader - > mode = mode ;
// TODO handle all shader types
if ( mode = = VS : : SHADER_CANVAS_ITEM ) {
shader - > shader = & canvas - > state . canvas_shader ;
2018-02-24 14:48:22 +01:00
} else if ( mode = = VS : : SHADER_SPATIAL ) {
shader - > shader = & scene - > state . scene_shader ;
2017-12-04 13:41:34 +01:00
} else {
return ;
}
if ( shader - > custom_code_id = = 0 ) {
shader - > custom_code_id = shader - > shader - > create_custom_shader ( ) ;
}
_shader_make_dirty ( shader ) ;
}
String RasterizerStorageGLES2 : : shader_get_code ( RID p_shader ) const {
const Shader * shader = shader_owner . get ( p_shader ) ;
ERR_FAIL_COND_V ( ! shader , " " ) ;
return shader - > code ;
}
void RasterizerStorageGLES2 : : _update_shader ( Shader * p_shader ) const {
_shader_dirty_list . remove ( & p_shader - > dirty_list ) ;
p_shader - > valid = false ;
p_shader - > uniforms . clear ( ) ;
2018-11-14 14:57:43 +01:00
if ( p_shader - > code = = String ( ) ) {
return ; //just invalid, but no error
}
2017-12-04 13:41:34 +01:00
ShaderCompilerGLES2 : : GeneratedCode gen_code ;
ShaderCompilerGLES2 : : IdentifierActions * actions = NULL ;
switch ( p_shader - > mode ) {
case VS : : SHADER_CANVAS_ITEM : {
2018-12-20 14:09:07 +01:00
p_shader - > canvas_item . light_mode = Shader : : CanvasItem : : LIGHT_MODE_NORMAL ;
2017-12-04 13:41:34 +01:00
p_shader - > canvas_item . blend_mode = Shader : : CanvasItem : : BLEND_MODE_MIX ;
p_shader - > canvas_item . uses_screen_texture = false ;
p_shader - > canvas_item . uses_screen_uv = false ;
p_shader - > canvas_item . uses_time = false ;
shaders . actions_canvas . render_mode_values [ " blend_add " ] = Pair < int * , int > ( & p_shader - > canvas_item . blend_mode , Shader : : CanvasItem : : BLEND_MODE_ADD ) ;
shaders . actions_canvas . render_mode_values [ " blend_mix " ] = Pair < int * , int > ( & p_shader - > canvas_item . blend_mode , Shader : : CanvasItem : : BLEND_MODE_MIX ) ;
shaders . actions_canvas . render_mode_values [ " blend_sub " ] = Pair < int * , int > ( & p_shader - > canvas_item . blend_mode , Shader : : CanvasItem : : BLEND_MODE_SUB ) ;
shaders . actions_canvas . render_mode_values [ " blend_mul " ] = Pair < int * , int > ( & p_shader - > canvas_item . blend_mode , Shader : : CanvasItem : : BLEND_MODE_MUL ) ;
shaders . actions_canvas . render_mode_values [ " blend_premul_alpha " ] = Pair < int * , int > ( & p_shader - > canvas_item . blend_mode , Shader : : CanvasItem : : BLEND_MODE_PMALPHA ) ;
2018-12-20 14:09:07 +01:00
shaders . actions_canvas . render_mode_values [ " unshaded " ] = Pair < int * , int > ( & p_shader - > canvas_item . light_mode , Shader : : CanvasItem : : LIGHT_MODE_UNSHADED ) ;
shaders . actions_canvas . render_mode_values [ " light_only " ] = Pair < int * , int > ( & p_shader - > canvas_item . light_mode , Shader : : CanvasItem : : LIGHT_MODE_LIGHT_ONLY ) ;
2017-12-04 13:41:34 +01:00
shaders . actions_canvas . usage_flag_pointers [ " SCREEN_UV " ] = & p_shader - > canvas_item . uses_screen_uv ;
shaders . actions_canvas . usage_flag_pointers [ " SCREEN_PIXEL_SIZE " ] = & p_shader - > canvas_item . uses_screen_uv ;
shaders . actions_canvas . usage_flag_pointers [ " SCREEN_TEXTURE " ] = & p_shader - > canvas_item . uses_screen_texture ;
shaders . actions_canvas . usage_flag_pointers [ " TIME " ] = & p_shader - > canvas_item . uses_time ;
actions = & shaders . actions_canvas ;
actions - > uniforms = & p_shader - > uniforms ;
} break ;
2018-02-24 14:48:22 +01:00
case VS : : SHADER_SPATIAL : {
p_shader - > spatial . blend_mode = Shader : : Spatial : : BLEND_MODE_MIX ;
p_shader - > spatial . depth_draw_mode = Shader : : Spatial : : DEPTH_DRAW_OPAQUE ;
p_shader - > spatial . cull_mode = Shader : : Spatial : : CULL_MODE_BACK ;
p_shader - > spatial . uses_alpha = false ;
p_shader - > spatial . uses_alpha_scissor = false ;
p_shader - > spatial . uses_discard = false ;
p_shader - > spatial . unshaded = false ;
p_shader - > spatial . no_depth_test = false ;
p_shader - > spatial . uses_sss = false ;
p_shader - > spatial . uses_time = false ;
p_shader - > spatial . uses_vertex_lighting = false ;
p_shader - > spatial . uses_screen_texture = false ;
p_shader - > spatial . uses_depth_texture = false ;
p_shader - > spatial . uses_vertex = false ;
p_shader - > spatial . writes_modelview_or_projection = false ;
p_shader - > spatial . uses_world_coordinates = false ;
shaders . actions_scene . render_mode_values [ " blend_add " ] = Pair < int * , int > ( & p_shader - > spatial . blend_mode , Shader : : Spatial : : BLEND_MODE_ADD ) ;
shaders . actions_scene . render_mode_values [ " blend_mix " ] = Pair < int * , int > ( & p_shader - > spatial . blend_mode , Shader : : Spatial : : BLEND_MODE_MIX ) ;
shaders . actions_scene . render_mode_values [ " blend_sub " ] = Pair < int * , int > ( & p_shader - > spatial . blend_mode , Shader : : Spatial : : BLEND_MODE_SUB ) ;
shaders . actions_scene . render_mode_values [ " blend_mul " ] = Pair < int * , int > ( & p_shader - > spatial . blend_mode , Shader : : Spatial : : BLEND_MODE_MUL ) ;
shaders . actions_scene . render_mode_values [ " depth_draw_opaque " ] = Pair < int * , int > ( & p_shader - > spatial . depth_draw_mode , Shader : : Spatial : : DEPTH_DRAW_OPAQUE ) ;
shaders . actions_scene . render_mode_values [ " depth_draw_always " ] = Pair < int * , int > ( & p_shader - > spatial . depth_draw_mode , Shader : : Spatial : : DEPTH_DRAW_ALWAYS ) ;
shaders . actions_scene . render_mode_values [ " depth_draw_never " ] = Pair < int * , int > ( & p_shader - > spatial . depth_draw_mode , Shader : : Spatial : : DEPTH_DRAW_NEVER ) ;
shaders . actions_scene . render_mode_values [ " depth_draw_alpha_prepass " ] = Pair < int * , int > ( & p_shader - > spatial . depth_draw_mode , Shader : : Spatial : : DEPTH_DRAW_ALPHA_PREPASS ) ;
shaders . actions_scene . render_mode_values [ " cull_front " ] = Pair < int * , int > ( & p_shader - > spatial . cull_mode , Shader : : Spatial : : CULL_MODE_FRONT ) ;
shaders . actions_scene . render_mode_values [ " cull_back " ] = Pair < int * , int > ( & p_shader - > spatial . cull_mode , Shader : : Spatial : : CULL_MODE_BACK ) ;
shaders . actions_scene . render_mode_values [ " cull_disabled " ] = Pair < int * , int > ( & p_shader - > spatial . cull_mode , Shader : : Spatial : : CULL_MODE_DISABLED ) ;
shaders . actions_scene . render_mode_flags [ " unshaded " ] = & p_shader - > spatial . unshaded ;
shaders . actions_scene . render_mode_flags [ " depth_test_disable " ] = & p_shader - > spatial . no_depth_test ;
shaders . actions_scene . render_mode_flags [ " vertex_lighting " ] = & p_shader - > spatial . uses_vertex_lighting ;
shaders . actions_scene . render_mode_flags [ " world_vertex_coords " ] = & p_shader - > spatial . uses_world_coordinates ;
shaders . actions_scene . usage_flag_pointers [ " ALPHA " ] = & p_shader - > spatial . uses_alpha ;
shaders . actions_scene . usage_flag_pointers [ " ALPHA_SCISSOR " ] = & p_shader - > spatial . uses_alpha_scissor ;
shaders . actions_scene . usage_flag_pointers [ " SSS_STRENGTH " ] = & p_shader - > spatial . uses_sss ;
shaders . actions_scene . usage_flag_pointers [ " DISCARD " ] = & p_shader - > spatial . uses_discard ;
shaders . actions_scene . usage_flag_pointers [ " SCREEN_TEXTURE " ] = & p_shader - > spatial . uses_screen_texture ;
shaders . actions_scene . usage_flag_pointers [ " DEPTH_TEXTURE " ] = & p_shader - > spatial . uses_depth_texture ;
shaders . actions_scene . usage_flag_pointers [ " TIME " ] = & p_shader - > spatial . uses_time ;
shaders . actions_scene . write_flag_pointers [ " MODELVIEW_MATRIX " ] = & p_shader - > spatial . writes_modelview_or_projection ;
shaders . actions_scene . write_flag_pointers [ " PROJECTION_MATRIX " ] = & p_shader - > spatial . writes_modelview_or_projection ;
shaders . actions_scene . write_flag_pointers [ " VERTEX " ] = & p_shader - > spatial . uses_vertex ;
actions = & shaders . actions_scene ;
actions - > uniforms = & p_shader - > uniforms ;
2019-02-22 15:32:37 +01:00
if ( p_shader - > spatial . uses_screen_texture & & p_shader - > spatial . uses_depth_texture ) {
2019-03-01 20:01:21 +01:00
ERR_PRINT_ONCE ( " Using both SCREEN_TEXTURE and DEPTH_TEXTURE is not supported in GLES2 " ) ;
2019-03-01 15:20:44 +01:00
}
if ( p_shader - > spatial . uses_depth_texture & & ! config . support_depth_texture ) {
2019-03-01 20:01:21 +01:00
ERR_PRINT_ONCE ( " Using DEPTH_TEXTURE is not permitted on this hardware, operation will fail. " ) ;
2019-02-22 15:32:37 +01:00
}
2018-02-24 14:48:22 +01:00
} break ;
2017-12-04 13:41:34 +01:00
default : {
return ;
} break ;
}
Error err = shaders . compiler . compile ( p_shader - > mode , p_shader - > code , actions , p_shader - > path , gen_code ) ;
2019-10-02 09:50:22 +02:00
if ( err ! = OK ) {
return ;
}
2017-12-04 13:41:34 +01:00
p_shader - > shader - > set_custom_shader_code ( p_shader - > custom_code_id , gen_code . vertex , gen_code . vertex_global , gen_code . fragment , gen_code . light , gen_code . fragment_global , gen_code . uniforms , gen_code . texture_uniforms , gen_code . custom_defines ) ;
p_shader - > texture_count = gen_code . texture_uniforms . size ( ) ;
p_shader - > texture_hints = gen_code . texture_hints ;
p_shader - > uses_vertex_time = gen_code . uses_vertex_time ;
p_shader - > uses_fragment_time = gen_code . uses_fragment_time ;
2018-02-24 14:48:22 +01:00
p_shader - > shader - > set_custom_shader ( p_shader - > custom_code_id ) ;
p_shader - > shader - > bind ( ) ;
// cache uniform locations
2017-12-04 13:41:34 +01:00
for ( SelfList < Material > * E = p_shader - > materials . first ( ) ; E ; E = E - > next ( ) ) {
_material_make_dirty ( E - > self ( ) ) ;
}
p_shader - > valid = true ;
p_shader - > version + + ;
}
void RasterizerStorageGLES2 : : update_dirty_shaders ( ) {
while ( _shader_dirty_list . first ( ) ) {
_update_shader ( _shader_dirty_list . first ( ) - > self ( ) ) ;
}
}
void RasterizerStorageGLES2 : : shader_get_param_list ( RID p_shader , List < PropertyInfo > * p_param_list ) const {
Shader * shader = shader_owner . get ( p_shader ) ;
ERR_FAIL_COND ( ! shader ) ;
if ( shader - > dirty_list . in_list ( ) ) {
_update_shader ( shader ) ;
}
Map < int , StringName > order ;
for ( Map < StringName , ShaderLanguage : : ShaderNode : : Uniform > : : Element * E = shader - > uniforms . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . texture_order > = 0 ) {
order [ E - > get ( ) . texture_order + 100000 ] = E - > key ( ) ;
} else {
order [ E - > get ( ) . order ] = E - > key ( ) ;
}
}
for ( Map < int , StringName > : : Element * E = order . front ( ) ; E ; E = E - > next ( ) ) {
PropertyInfo pi ;
ShaderLanguage : : ShaderNode : : Uniform & u = shader - > uniforms [ E - > get ( ) ] ;
pi . name = E - > get ( ) ;
switch ( u . type ) {
case ShaderLanguage : : TYPE_VOID : {
pi . type = Variant : : NIL ;
} break ;
case ShaderLanguage : : TYPE_BOOL : {
pi . type = Variant : : BOOL ;
} break ;
// bool vectors
case ShaderLanguage : : TYPE_BVEC2 : {
pi . type = Variant : : INT ;
pi . hint = PROPERTY_HINT_FLAGS ;
pi . hint_string = " x,y " ;
} break ;
case ShaderLanguage : : TYPE_BVEC3 : {
pi . type = Variant : : INT ;
pi . hint = PROPERTY_HINT_FLAGS ;
pi . hint_string = " x,y,z " ;
} break ;
case ShaderLanguage : : TYPE_BVEC4 : {
pi . type = Variant : : INT ;
pi . hint = PROPERTY_HINT_FLAGS ;
pi . hint_string = " x,y,z,w " ;
} break ;
// int stuff
case ShaderLanguage : : TYPE_UINT :
case ShaderLanguage : : TYPE_INT : {
pi . type = Variant : : INT ;
if ( u . hint = = ShaderLanguage : : ShaderNode : : Uniform : : HINT_RANGE ) {
pi . hint = PROPERTY_HINT_RANGE ;
2019-08-25 14:11:04 +02:00
pi . hint_string = rtos ( u . hint_range [ 0 ] ) + " , " + rtos ( u . hint_range [ 1 ] ) + " , " + rtos ( u . hint_range [ 2 ] ) ;
2017-12-04 13:41:34 +01:00
}
} break ;
case ShaderLanguage : : TYPE_IVEC2 :
case ShaderLanguage : : TYPE_UVEC2 :
case ShaderLanguage : : TYPE_IVEC3 :
case ShaderLanguage : : TYPE_UVEC3 :
case ShaderLanguage : : TYPE_IVEC4 :
case ShaderLanguage : : TYPE_UVEC4 : {
pi . type = Variant : : POOL_INT_ARRAY ;
} break ;
2018-02-24 14:48:22 +01:00
case ShaderLanguage : : TYPE_FLOAT : {
pi . type = Variant : : REAL ;
2019-04-08 11:53:57 +02:00
if ( u . hint = = ShaderLanguage : : ShaderNode : : Uniform : : HINT_RANGE ) {
pi . hint = PROPERTY_HINT_RANGE ;
pi . hint_string = rtos ( u . hint_range [ 0 ] ) + " , " + rtos ( u . hint_range [ 1 ] ) + " , " + rtos ( u . hint_range [ 2 ] ) ;
}
2018-02-24 14:48:22 +01:00
} break ;
2017-12-04 13:41:34 +01:00
case ShaderLanguage : : TYPE_VEC2 : {
pi . type = Variant : : VECTOR2 ;
} break ;
case ShaderLanguage : : TYPE_VEC3 : {
pi . type = Variant : : VECTOR3 ;
} break ;
case ShaderLanguage : : TYPE_VEC4 : {
if ( u . hint = = ShaderLanguage : : ShaderNode : : Uniform : : HINT_COLOR ) {
pi . type = Variant : : COLOR ;
} else {
pi . type = Variant : : PLANE ;
}
} break ;
case ShaderLanguage : : TYPE_MAT2 : {
pi . type = Variant : : TRANSFORM2D ;
} break ;
case ShaderLanguage : : TYPE_MAT3 : {
pi . type = Variant : : BASIS ;
} break ;
case ShaderLanguage : : TYPE_MAT4 : {
pi . type = Variant : : TRANSFORM ;
} break ;
case ShaderLanguage : : TYPE_SAMPLER2D :
case ShaderLanguage : : TYPE_ISAMPLER2D :
case ShaderLanguage : : TYPE_USAMPLER2D : {
pi . type = Variant : : OBJECT ;
pi . hint = PROPERTY_HINT_RESOURCE_TYPE ;
pi . hint_string = " Texture " ;
} break ;
case ShaderLanguage : : TYPE_SAMPLERCUBE : {
pi . type = Variant : : OBJECT ;
pi . hint = PROPERTY_HINT_RESOURCE_TYPE ;
pi . hint_string = " CubeMap " ;
} break ;
2018-08-23 16:46:43 +02:00
2018-09-26 13:13:56 +02:00
case ShaderLanguage : : TYPE_SAMPLER2DARRAY :
case ShaderLanguage : : TYPE_ISAMPLER2DARRAY :
case ShaderLanguage : : TYPE_USAMPLER2DARRAY :
case ShaderLanguage : : TYPE_SAMPLER3D :
case ShaderLanguage : : TYPE_ISAMPLER3D :
case ShaderLanguage : : TYPE_USAMPLER3D : {
// Not implemented in GLES2
2018-08-23 16:46:43 +02:00
} break ;
2017-12-04 13:41:34 +01:00
}
p_param_list - > push_back ( pi ) ;
}
}
void RasterizerStorageGLES2 : : shader_set_default_texture_param ( RID p_shader , const StringName & p_name , RID p_texture ) {
Shader * shader = shader_owner . get ( p_shader ) ;
ERR_FAIL_COND ( ! shader ) ;
ERR_FAIL_COND ( p_texture . is_valid ( ) & & ! texture_owner . owns ( p_texture ) ) ;
if ( p_texture . is_valid ( ) ) {
shader - > default_textures [ p_name ] = p_texture ;
} else {
shader - > default_textures . erase ( p_name ) ;
}
_shader_make_dirty ( shader ) ;
}
RID RasterizerStorageGLES2 : : shader_get_default_texture_param ( RID p_shader , const StringName & p_name ) const {
const Shader * shader = shader_owner . get ( p_shader ) ;
ERR_FAIL_COND_V ( ! shader , RID ( ) ) ;
const Map < StringName , RID > : : Element * E = shader - > default_textures . find ( p_name ) ;
if ( ! E ) {
return RID ( ) ;
}
return E - > get ( ) ;
}
/* COMMON MATERIAL API */
void RasterizerStorageGLES2 : : _material_make_dirty ( Material * p_material ) const {
if ( p_material - > dirty_list . in_list ( ) )
return ;
_material_dirty_list . add ( & p_material - > dirty_list ) ;
}
RID RasterizerStorageGLES2 : : material_create ( ) {
Material * material = memnew ( Material ) ;
return material_owner . make_rid ( material ) ;
}
void RasterizerStorageGLES2 : : material_set_shader ( RID p_material , RID p_shader ) {
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
Shader * shader = shader_owner . getornull ( p_shader ) ;
if ( material - > shader ) {
// if a shader is present, remove the old shader
material - > shader - > materials . remove ( & material - > list ) ;
}
material - > shader = shader ;
if ( shader ) {
shader - > materials . add ( & material - > list ) ;
}
_material_make_dirty ( material ) ;
}
RID RasterizerStorageGLES2 : : material_get_shader ( RID p_material ) const {
const Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND_V ( ! material , RID ( ) ) ;
if ( material - > shader ) {
return material - > shader - > self ;
}
return RID ( ) ;
}
void RasterizerStorageGLES2 : : material_set_param ( RID p_material , const StringName & p_param , const Variant & p_value ) {
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
if ( p_value . get_type ( ) = = Variant : : NIL ) {
material - > params . erase ( p_param ) ;
} else {
material - > params [ p_param ] = p_value ;
}
_material_make_dirty ( material ) ;
}
Variant RasterizerStorageGLES2 : : material_get_param ( RID p_material , const StringName & p_param ) const {
const Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND_V ( ! material , RID ( ) ) ;
if ( material - > params . has ( p_param ) ) {
return material - > params [ p_param ] ;
}
2018-09-05 00:54:35 +02:00
return material_get_param_default ( p_material , p_param ) ;
}
Variant RasterizerStorageGLES2 : : material_get_param_default ( RID p_material , const StringName & p_param ) const {
const Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND_V ( ! material , Variant ( ) ) ;
if ( material - > shader ) {
if ( material - > shader - > uniforms . has ( p_param ) ) {
2018-11-16 12:20:23 +01:00
ShaderLanguage : : ShaderNode : : Uniform uniform = material - > shader - > uniforms [ p_param ] ;
Vector < ShaderLanguage : : ConstantNode : : Value > default_value = uniform . default_value ;
return ShaderLanguage : : constant_value_to_variant ( default_value , uniform . type , uniform . hint ) ;
2018-09-05 00:54:35 +02:00
}
}
2017-12-04 13:41:34 +01:00
return Variant ( ) ;
}
void RasterizerStorageGLES2 : : material_set_line_width ( RID p_material , float p_width ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . getornull ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
material - > line_width = p_width ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : material_set_next_pass ( RID p_material , RID p_next_material ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
material - > next_pass = p_next_material ;
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : material_is_animated ( RID p_material ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND_V ( ! material , false ) ;
if ( material - > dirty_list . in_list ( ) ) {
_update_material ( material ) ;
}
bool animated = material - > is_animated_cache ;
if ( ! animated & & material - > next_pass . is_valid ( ) ) {
animated = material_is_animated ( material - > next_pass ) ;
}
return animated ;
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : material_casts_shadows ( RID p_material ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND_V ( ! material , false ) ;
if ( material - > dirty_list . in_list ( ) ) {
_update_material ( material ) ;
}
bool casts_shadows = material - > can_cast_shadow_cache ;
if ( ! casts_shadows & & material - > next_pass . is_valid ( ) ) {
casts_shadows = material_casts_shadows ( material - > next_pass ) ;
}
return casts_shadows ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : material_add_instance_owner ( RID p_material , RasterizerScene : : InstanceBase * p_instance ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . getornull ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
Map < RasterizerScene : : InstanceBase * , int > : : Element * E = material - > instance_owners . find ( p_instance ) ;
if ( E ) {
E - > get ( ) + + ;
} else {
material - > instance_owners [ p_instance ] = 1 ;
}
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : material_remove_instance_owner ( RID p_material , RasterizerScene : : InstanceBase * p_instance ) {
2018-02-24 14:48:22 +01:00
Material * material = material_owner . getornull ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
Map < RasterizerScene : : InstanceBase * , int > : : Element * E = material - > instance_owners . find ( p_instance ) ;
ERR_FAIL_COND ( ! E ) ;
E - > get ( ) - - ;
if ( E - > get ( ) = = 0 ) {
material - > instance_owners . erase ( E ) ;
}
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : material_set_render_priority ( RID p_material , int priority ) {
2018-02-24 14:48:22 +01:00
ERR_FAIL_COND ( priority < VS : : MATERIAL_RENDER_PRIORITY_MIN ) ;
ERR_FAIL_COND ( priority > VS : : MATERIAL_RENDER_PRIORITY_MAX ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Material * material = material_owner . get ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
material - > render_priority = priority ;
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : _update_material ( Material * p_material ) {
if ( p_material - > dirty_list . in_list ( ) ) {
_material_dirty_list . remove ( & p_material - > dirty_list ) ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader & & p_material - > shader - > dirty_list . in_list ( ) ) {
_update_shader ( p_material - > shader ) ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader & & ! p_material - > shader - > valid ) {
return ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
{
bool can_cast_shadow = false ;
bool is_animated = false ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader & & p_material - > shader - > mode = = VS : : SHADER_SPATIAL ) {
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader - > spatial . blend_mode = = Shader : : Spatial : : BLEND_MODE_MIX & &
2018-11-04 10:14:50 +01:00
( ! p_material - > shader - > spatial . uses_alpha | | p_material - > shader - > spatial . depth_draw_mode = = Shader : : Spatial : : DEPTH_DRAW_ALPHA_PREPASS ) ) {
2018-02-24 14:48:22 +01:00
can_cast_shadow = true ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader - > spatial . uses_discard & & p_material - > shader - > uses_fragment_time ) {
is_animated = true ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader - > spatial . uses_vertex & & p_material - > shader - > uses_vertex_time ) {
is_animated = true ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( can_cast_shadow ! = p_material - > can_cast_shadow_cache | | is_animated ! = p_material - > is_animated_cache ) {
p_material - > can_cast_shadow_cache = can_cast_shadow ;
p_material - > is_animated_cache = is_animated ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
for ( Map < Geometry * , int > : : Element * E = p_material - > geometry_owners . front ( ) ; E ; E = E - > next ( ) ) {
E - > key ( ) - > material_changed_notify ( ) ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
for ( Map < RasterizerScene : : InstanceBase * , int > : : Element * E = p_material - > instance_owners . front ( ) ; E ; E = E - > next ( ) ) {
2018-11-14 13:32:39 +01:00
E - > key ( ) - > base_changed ( false , true ) ;
2018-02-24 14:48:22 +01:00
}
}
}
}
2017-12-04 13:41:34 +01:00
2018-09-13 03:38:39 +02:00
// uniforms and other things will be set in the use_material method in ShaderGLES2
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( p_material - > shader & & p_material - > shader - > texture_count > 0 ) {
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
p_material - > textures . resize ( p_material - > shader - > texture_count ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
for ( Map < StringName , ShaderLanguage : : ShaderNode : : Uniform > : : Element * E = p_material - > shader - > uniforms . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . texture_order < 0 )
continue ; // not a texture, does not go here
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
RID texture ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Map < StringName , Variant > : : Element * V = p_material - > params . find ( E - > key ( ) ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( V ) {
texture = V - > get ( ) ;
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( ! texture . is_valid ( ) ) {
Map < StringName , RID > : : Element * W = p_material - > shader - > default_textures . find ( E - > key ( ) ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( W ) {
texture = W - > get ( ) ;
}
}
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
p_material - > textures . write [ E - > get ( ) . texture_order ] = Pair < StringName , RID > ( E - > key ( ) , texture ) ;
}
} else {
p_material - > textures . clear ( ) ;
}
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : _material_add_geometry ( RID p_material , Geometry * p_geometry ) {
Material * material = material_owner . getornull ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Map < Geometry * , int > : : Element * I = material - > geometry_owners . find ( p_geometry ) ;
if ( I ) {
I - > get ( ) + + ;
} else {
material - > geometry_owners [ p_geometry ] = 1 ;
}
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : _material_remove_geometry ( RID p_material , Geometry * p_geometry ) {
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Material * material = material_owner . getornull ( p_material ) ;
ERR_FAIL_COND ( ! material ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Map < Geometry * , int > : : Element * I = material - > geometry_owners . find ( p_geometry ) ;
ERR_FAIL_COND ( ! I ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
I - > get ( ) - - ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
if ( I - > get ( ) = = 0 ) {
material - > geometry_owners . erase ( I ) ;
}
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : update_dirty_materials ( ) {
while ( _material_dirty_list . first ( ) ) {
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
Material * material = _material_dirty_list . first ( ) - > self ( ) ;
_update_material ( material ) ;
}
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
/* MESH API */
RID RasterizerStorageGLES2 : : mesh_create ( ) {
Mesh * mesh = memnew ( Mesh ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
return mesh_owner . make_rid ( mesh ) ;
}
2019-01-23 01:56:24 +01:00
static PoolVector < uint8_t > _unpack_half_floats ( const PoolVector < uint8_t > & array , uint32_t & format , int p_vertices ) {
uint32_t p_format = format ;
static int src_size [ VS : : ARRAY_MAX ] ;
static int dst_size [ VS : : ARRAY_MAX ] ;
static int to_convert [ VS : : ARRAY_MAX ] ;
int src_stride = 0 ;
int dst_stride = 0 ;
for ( int i = 0 ; i < VS : : ARRAY_MAX ; i + + ) {
to_convert [ i ] = 0 ;
if ( ! ( p_format & ( 1 < < i ) ) ) {
src_size [ i ] = 0 ;
dst_size [ i ] = 0 ;
continue ;
}
switch ( i ) {
case VS : : ARRAY_VERTEX : {
if ( p_format & VS : : ARRAY_COMPRESS_VERTEX ) {
if ( p_format & VS : : ARRAY_FLAG_USE_2D_VERTICES ) {
src_size [ i ] = 4 ;
dst_size [ i ] = 8 ;
to_convert [ i ] = 2 ;
} else {
src_size [ i ] = 8 ;
dst_size [ i ] = 12 ;
to_convert [ i ] = 3 ;
}
format & = ~ VS : : ARRAY_COMPRESS_VERTEX ;
} else {
if ( p_format & VS : : ARRAY_FLAG_USE_2D_VERTICES ) {
src_size [ i ] = 8 ;
dst_size [ i ] = 8 ;
} else {
src_size [ i ] = 12 ;
dst_size [ i ] = 12 ;
}
}
} break ;
case VS : : ARRAY_NORMAL : {
if ( p_format & VS : : ARRAY_COMPRESS_NORMAL ) {
src_size [ i ] = 4 ;
dst_size [ i ] = 4 ;
} else {
src_size [ i ] = 12 ;
dst_size [ i ] = 12 ;
}
} break ;
case VS : : ARRAY_TANGENT : {
if ( p_format & VS : : ARRAY_COMPRESS_TANGENT ) {
src_size [ i ] = 4 ;
dst_size [ i ] = 4 ;
} else {
src_size [ i ] = 16 ;
dst_size [ i ] = 16 ;
}
} break ;
case VS : : ARRAY_COLOR : {
if ( p_format & VS : : ARRAY_COMPRESS_COLOR ) {
src_size [ i ] = 4 ;
dst_size [ i ] = 4 ;
} else {
src_size [ i ] = 16 ;
dst_size [ i ] = 16 ;
}
} break ;
case VS : : ARRAY_TEX_UV : {
if ( p_format & VS : : ARRAY_COMPRESS_TEX_UV ) {
src_size [ i ] = 4 ;
to_convert [ i ] = 2 ;
format & = ~ VS : : ARRAY_COMPRESS_TEX_UV ;
} else {
src_size [ i ] = 8 ;
}
dst_size [ i ] = 8 ;
} break ;
case VS : : ARRAY_TEX_UV2 : {
if ( p_format & VS : : ARRAY_COMPRESS_TEX_UV2 ) {
src_size [ i ] = 4 ;
to_convert [ i ] = 2 ;
format & = ~ VS : : ARRAY_COMPRESS_TEX_UV2 ;
} else {
src_size [ i ] = 8 ;
}
dst_size [ i ] = 8 ;
} break ;
case VS : : ARRAY_BONES : {
if ( p_format & VS : : ARRAY_FLAG_USE_16_BIT_BONES ) {
src_size [ i ] = 8 ;
dst_size [ i ] = 8 ;
} else {
src_size [ i ] = 4 ;
dst_size [ i ] = 4 ;
}
} break ;
case VS : : ARRAY_WEIGHTS : {
if ( p_format & VS : : ARRAY_COMPRESS_WEIGHTS ) {
src_size [ i ] = 8 ;
dst_size [ i ] = 8 ;
} else {
src_size [ i ] = 16 ;
dst_size [ i ] = 16 ;
}
} break ;
case VS : : ARRAY_INDEX : {
src_size [ i ] = 0 ;
dst_size [ i ] = 0 ;
} break ;
}
src_stride + = src_size [ i ] ;
dst_stride + = dst_size [ i ] ;
}
PoolVector < uint8_t > ret ;
ret . resize ( p_vertices * dst_stride ) ;
PoolVector < uint8_t > : : Read r = array . read ( ) ;
PoolVector < uint8_t > : : Write w = ret . write ( ) ;
int src_offset = 0 ;
int dst_offset = 0 ;
for ( int i = 0 ; i < VS : : ARRAY_MAX ; i + + ) {
if ( src_size [ i ] = = 0 ) {
continue ; //no go
}
const uint8_t * rptr = r . ptr ( ) ;
uint8_t * wptr = w . ptr ( ) ;
if ( to_convert [ i ] ) { //converting
for ( int j = 0 ; j < p_vertices ; j + + ) {
const uint16_t * src = ( const uint16_t * ) & rptr [ src_stride * j + src_offset ] ;
float * dst = ( float * ) & wptr [ dst_stride * j + dst_offset ] ;
for ( int k = 0 ; k < to_convert [ i ] ; k + + ) {
dst [ k ] = Math : : half_to_float ( src [ k ] ) ;
}
}
} else {
//just copy
for ( int j = 0 ; j < p_vertices ; j + + ) {
for ( int k = 0 ; k < src_size [ i ] ; k + + ) {
wptr [ dst_stride * j + dst_offset + k ] = rptr [ src_stride * j + src_offset + k ] ;
}
}
}
src_offset + = src_size [ i ] ;
dst_offset + = dst_size [ i ] ;
}
2019-07-05 19:08:43 +02:00
r . release ( ) ;
w . release ( ) ;
2019-01-23 01:56:24 +01:00
return ret ;
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : mesh_add_surface ( RID p_mesh , uint32_t p_format , VS : : PrimitiveType p_primitive , const PoolVector < uint8_t > & p_array , int p_vertex_count , const PoolVector < uint8_t > & p_index_array , int p_index_count , const AABB & p_aabb , const Vector < PoolVector < uint8_t > > & p_blend_shapes , const Vector < AABB > & p_bone_aabbs ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
ERR_FAIL_COND ( ! ( p_format & VS : : ARRAY_FORMAT_VERTEX ) ) ;
//must have index and bones, both.
{
uint32_t bones_weight = VS : : ARRAY_FORMAT_BONES | VS : : ARRAY_FORMAT_WEIGHTS ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_COND_MSG ( ( p_format & bones_weight ) & & ( p_format & bones_weight ) ! = bones_weight , " Array must have both bones and weights in format or none. " ) ;
2018-02-24 14:48:22 +01:00
}
//bool has_morph = p_blend_shapes.size();
Surface : : Attrib attribs [ VS : : ARRAY_MAX ] ;
int stride = 0 ;
2019-01-23 01:56:24 +01:00
bool uses_half_float = false ;
2018-02-24 14:48:22 +01:00
for ( int i = 0 ; i < VS : : ARRAY_MAX ; i + + ) {
attribs [ i ] . index = i ;
if ( ! ( p_format & ( 1 < < i ) ) ) {
attribs [ i ] . enabled = false ;
attribs [ i ] . integer = false ;
continue ;
}
attribs [ i ] . enabled = true ;
attribs [ i ] . offset = stride ;
attribs [ i ] . integer = false ;
switch ( i ) {
case VS : : ARRAY_VERTEX : {
if ( p_format & VS : : ARRAY_FLAG_USE_2D_VERTICES ) {
attribs [ i ] . size = 2 ;
} else {
attribs [ i ] . size = ( p_format & VS : : ARRAY_COMPRESS_VERTEX ) ? 4 : 3 ;
}
if ( p_format & VS : : ARRAY_COMPRESS_VERTEX ) {
attribs [ i ] . type = _GL_HALF_FLOAT_OES ;
stride + = attribs [ i ] . size * 2 ;
2019-01-23 01:56:24 +01:00
uses_half_float = true ;
2018-02-24 14:48:22 +01:00
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = attribs [ i ] . size * 4 ;
}
attribs [ i ] . normalized = GL_FALSE ;
} break ;
case VS : : ARRAY_NORMAL : {
attribs [ i ] . size = 3 ;
if ( p_format & VS : : ARRAY_COMPRESS_NORMAL ) {
attribs [ i ] . type = GL_BYTE ;
stride + = 4 ; //pad extra byte
attribs [ i ] . normalized = GL_TRUE ;
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 12 ;
attribs [ i ] . normalized = GL_FALSE ;
}
} break ;
case VS : : ARRAY_TANGENT : {
attribs [ i ] . size = 4 ;
if ( p_format & VS : : ARRAY_COMPRESS_TANGENT ) {
attribs [ i ] . type = GL_BYTE ;
stride + = 4 ;
attribs [ i ] . normalized = GL_TRUE ;
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 16 ;
attribs [ i ] . normalized = GL_FALSE ;
}
} break ;
case VS : : ARRAY_COLOR : {
attribs [ i ] . size = 4 ;
if ( p_format & VS : : ARRAY_COMPRESS_COLOR ) {
attribs [ i ] . type = GL_UNSIGNED_BYTE ;
stride + = 4 ;
attribs [ i ] . normalized = GL_TRUE ;
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 16 ;
attribs [ i ] . normalized = GL_FALSE ;
}
} break ;
case VS : : ARRAY_TEX_UV : {
attribs [ i ] . size = 2 ;
if ( p_format & VS : : ARRAY_COMPRESS_TEX_UV ) {
attribs [ i ] . type = _GL_HALF_FLOAT_OES ;
stride + = 4 ;
2019-01-23 01:56:24 +01:00
uses_half_float = true ;
2018-02-24 14:48:22 +01:00
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 8 ;
}
attribs [ i ] . normalized = GL_FALSE ;
} break ;
case VS : : ARRAY_TEX_UV2 : {
attribs [ i ] . size = 2 ;
if ( p_format & VS : : ARRAY_COMPRESS_TEX_UV2 ) {
attribs [ i ] . type = _GL_HALF_FLOAT_OES ;
stride + = 4 ;
2019-01-23 01:56:24 +01:00
uses_half_float = true ;
2018-02-24 14:48:22 +01:00
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 8 ;
}
attribs [ i ] . normalized = GL_FALSE ;
} break ;
case VS : : ARRAY_BONES : {
attribs [ i ] . size = 4 ;
if ( p_format & VS : : ARRAY_FLAG_USE_16_BIT_BONES ) {
attribs [ i ] . type = GL_UNSIGNED_SHORT ;
stride + = 8 ;
} else {
attribs [ i ] . type = GL_UNSIGNED_BYTE ;
stride + = 4 ;
}
attribs [ i ] . normalized = GL_FALSE ;
attribs [ i ] . integer = true ;
} break ;
case VS : : ARRAY_WEIGHTS : {
attribs [ i ] . size = 4 ;
if ( p_format & VS : : ARRAY_COMPRESS_WEIGHTS ) {
attribs [ i ] . type = GL_UNSIGNED_SHORT ;
stride + = 8 ;
attribs [ i ] . normalized = GL_TRUE ;
} else {
attribs [ i ] . type = GL_FLOAT ;
stride + = 16 ;
attribs [ i ] . normalized = GL_FALSE ;
}
} break ;
case VS : : ARRAY_INDEX : {
attribs [ i ] . size = 1 ;
if ( p_vertex_count > = ( 1 < < 16 ) ) {
attribs [ i ] . type = GL_UNSIGNED_INT ;
attribs [ i ] . stride = 4 ;
} else {
attribs [ i ] . type = GL_UNSIGNED_SHORT ;
attribs [ i ] . stride = 2 ;
}
attribs [ i ] . normalized = GL_FALSE ;
} break ;
}
}
for ( int i = 0 ; i < VS : : ARRAY_MAX - 1 ; i + + ) {
attribs [ i ] . stride = stride ;
}
//validate sizes
2019-01-23 01:56:24 +01:00
PoolVector < uint8_t > array = p_array ;
2018-02-24 14:48:22 +01:00
int array_size = stride * p_vertex_count ;
int index_array_size = 0 ;
if ( array . size ( ) ! = array_size & & array . size ( ) + p_vertex_count * 2 = = array_size ) {
//old format, convert
array = PoolVector < uint8_t > ( ) ;
array . resize ( p_array . size ( ) + p_vertex_count * 2 ) ;
PoolVector < uint8_t > : : Write w = array . write ( ) ;
PoolVector < uint8_t > : : Read r = p_array . read ( ) ;
uint16_t * w16 = ( uint16_t * ) w . ptr ( ) ;
const uint16_t * r16 = ( uint16_t * ) r . ptr ( ) ;
uint16_t one = Math : : make_half_float ( 1 ) ;
for ( int i = 0 ; i < p_vertex_count ; i + + ) {
* w16 + + = * r16 + + ;
* w16 + + = * r16 + + ;
* w16 + + = * r16 + + ;
* w16 + + = one ;
for ( int j = 0 ; j < ( stride / 2 ) - 4 ; j + + ) {
* w16 + + = * r16 + + ;
}
}
}
ERR_FAIL_COND ( array . size ( ) ! = array_size ) ;
2019-01-23 01:56:24 +01:00
if ( ! config . support_half_float_vertices & & uses_half_float ) {
uint32_t new_format = p_format ;
PoolVector < uint8_t > unpacked_array = _unpack_half_floats ( array , new_format , p_vertex_count ) ;
mesh_add_surface ( p_mesh , new_format , p_primitive , unpacked_array , p_vertex_count , p_index_array , p_index_count , p_aabb , p_blend_shapes , p_bone_aabbs ) ;
return ; //do not go any further, above function used unpacked stuff will be used instead.
}
2018-02-24 14:48:22 +01:00
if ( p_format & VS : : ARRAY_FORMAT_INDEX ) {
index_array_size = attribs [ VS : : ARRAY_INDEX ] . stride * p_index_count ;
}
ERR_FAIL_COND ( p_index_array . size ( ) ! = index_array_size ) ;
ERR_FAIL_COND ( p_blend_shapes . size ( ) ! = mesh - > blend_shape_count ) ;
for ( int i = 0 ; i < p_blend_shapes . size ( ) ; i + + ) {
ERR_FAIL_COND ( p_blend_shapes [ i ] . size ( ) ! = array_size ) ;
}
// all valid, create stuff
Surface * surface = memnew ( Surface ) ;
surface - > active = true ;
surface - > array_len = p_vertex_count ;
surface - > index_array_len = p_index_count ;
surface - > array_byte_size = array . size ( ) ;
surface - > index_array_byte_size = p_index_array . size ( ) ;
surface - > primitive = p_primitive ;
surface - > mesh = mesh ;
surface - > format = p_format ;
surface - > skeleton_bone_aabb = p_bone_aabbs ;
surface - > skeleton_bone_used . resize ( surface - > skeleton_bone_aabb . size ( ) ) ;
surface - > aabb = p_aabb ;
surface - > max_bone = p_bone_aabbs . size ( ) ;
2019-03-01 20:01:21 +01:00
# ifdef TOOLS_ENABLED
surface - > blend_shape_data = p_blend_shapes ;
if ( surface - > blend_shape_data . size ( ) ) {
ERR_PRINT_ONCE ( " Blend shapes are not supported in OpenGL ES 2.0 " ) ;
}
# endif
2018-02-24 14:48:22 +01:00
2020-01-03 22:39:40 +01:00
surface - > data = array ;
surface - > index_data = p_index_array ;
2018-02-24 14:48:22 +01:00
surface - > total_data_size + = surface - > array_byte_size + surface - > index_array_byte_size ;
for ( int i = 0 ; i < surface - > skeleton_bone_used . size ( ) ; i + + ) {
2019-03-03 16:23:03 +01:00
surface - > skeleton_bone_used . write [ i ] = ! ( surface - > skeleton_bone_aabb [ i ] . size . x < 0 | | surface - > skeleton_bone_aabb [ i ] . size . y < 0 | | surface - > skeleton_bone_aabb [ i ] . size . z < 0 ) ;
2018-02-24 14:48:22 +01:00
}
for ( int i = 0 ; i < VS : : ARRAY_MAX ; i + + ) {
surface - > attribs [ i ] = attribs [ i ] ;
}
// Okay, now the OpenGL stuff, wheeeeey \o/
{
PoolVector < uint8_t > : : Read vr = array . read ( ) ;
glGenBuffers ( 1 , & surface - > vertex_id ) ;
glBindBuffer ( GL_ARRAY_BUFFER , surface - > vertex_id ) ;
glBufferData ( GL_ARRAY_BUFFER , array_size , vr . ptr ( ) , ( p_format & VS : : ARRAY_FLAG_USE_DYNAMIC_UPDATE ) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW ) ;
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
if ( p_format & VS : : ARRAY_FORMAT_INDEX ) {
PoolVector < uint8_t > : : Read ir = p_index_array . read ( ) ;
glGenBuffers ( 1 , & surface - > index_id ) ;
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , surface - > index_id ) ;
glBufferData ( GL_ELEMENT_ARRAY_BUFFER , index_array_size , ir . ptr ( ) , GL_STATIC_DRAW ) ;
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , 0 ) ;
2019-02-24 04:32:34 +01:00
} else {
surface - > index_id = 0 ;
2018-02-24 14:48:22 +01:00
}
// TODO generate wireframes
}
{
// blend shapes
for ( int i = 0 ; i < p_blend_shapes . size ( ) ; i + + ) {
Surface : : BlendShape mt ;
PoolVector < uint8_t > : : Read vr = p_blend_shapes [ i ] . read ( ) ;
surface - > total_data_size + = array_size ;
glGenBuffers ( 1 , & mt . vertex_id ) ;
glBindBuffer ( GL_ARRAY_BUFFER , mt . vertex_id ) ;
glBufferData ( GL_ARRAY_BUFFER , array_size , vr . ptr ( ) , GL_STATIC_DRAW ) ;
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
surface - > blend_shapes . push_back ( mt ) ;
}
}
mesh - > surfaces . push_back ( surface ) ;
2019-02-22 20:26:19 +01:00
mesh - > instance_change_notify ( true , true ) ;
2018-02-24 14:48:22 +01:00
info . vertex_mem + = surface - > total_data_size ;
}
void RasterizerStorageGLES2 : : mesh_set_blend_shape_count ( RID p_mesh , int p_amount ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
ERR_FAIL_COND ( mesh - > surfaces . size ( ) ! = 0 ) ;
ERR_FAIL_COND ( p_amount < 0 ) ;
mesh - > blend_shape_count = p_amount ;
2019-03-01 20:01:21 +01:00
mesh - > instance_change_notify ( true , false ) ;
2018-02-24 14:48:22 +01:00
}
int RasterizerStorageGLES2 : : mesh_get_blend_shape_count ( RID p_mesh ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , 0 ) ;
return mesh - > blend_shape_count ;
}
void RasterizerStorageGLES2 : : mesh_set_blend_shape_mode ( RID p_mesh , VS : : BlendShapeMode p_mode ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
mesh - > blend_shape_mode = p_mode ;
}
VS : : BlendShapeMode RasterizerStorageGLES2 : : mesh_get_blend_shape_mode ( RID p_mesh ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , VS : : BLEND_SHAPE_MODE_NORMALIZED ) ;
return mesh - > blend_shape_mode ;
}
void RasterizerStorageGLES2 : : mesh_surface_update_region ( RID p_mesh , int p_surface , int p_offset , const PoolVector < uint8_t > & p_data ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
ERR_FAIL_INDEX ( p_surface , mesh - > surfaces . size ( ) ) ;
int total_size = p_data . size ( ) ;
ERR_FAIL_COND ( p_offset + total_size > mesh - > surfaces [ p_surface ] - > array_byte_size ) ;
PoolVector < uint8_t > : : Read r = p_data . read ( ) ;
glBindBuffer ( GL_ARRAY_BUFFER , mesh - > surfaces [ p_surface ] - > vertex_id ) ;
glBufferSubData ( GL_ARRAY_BUFFER , p_offset , total_size , r . ptr ( ) ) ;
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ; //unbind
}
void RasterizerStorageGLES2 : : mesh_surface_set_material ( RID p_mesh , int p_surface , RID p_material ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
ERR_FAIL_INDEX ( p_surface , mesh - > surfaces . size ( ) ) ;
if ( mesh - > surfaces [ p_surface ] - > material = = p_material )
return ;
if ( mesh - > surfaces [ p_surface ] - > material . is_valid ( ) ) {
_material_remove_geometry ( mesh - > surfaces [ p_surface ] - > material , mesh - > surfaces [ p_surface ] ) ;
}
mesh - > surfaces [ p_surface ] - > material = p_material ;
if ( mesh - > surfaces [ p_surface ] - > material . is_valid ( ) ) {
_material_add_geometry ( mesh - > surfaces [ p_surface ] - > material , mesh - > surfaces [ p_surface ] ) ;
}
2018-11-14 13:32:39 +01:00
mesh - > instance_change_notify ( false , true ) ;
2018-02-24 14:48:22 +01:00
}
RID RasterizerStorageGLES2 : : mesh_surface_get_material ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , RID ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , RID ( ) ) ;
return mesh - > surfaces [ p_surface ] - > material ;
}
int RasterizerStorageGLES2 : : mesh_surface_get_array_len ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , 0 ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , 0 ) ;
return mesh - > surfaces [ p_surface ] - > array_len ;
}
int RasterizerStorageGLES2 : : mesh_surface_get_array_index_len ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , 0 ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , 0 ) ;
return mesh - > surfaces [ p_surface ] - > index_array_len ;
}
PoolVector < uint8_t > RasterizerStorageGLES2 : : mesh_surface_get_array ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , PoolVector < uint8_t > ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , PoolVector < uint8_t > ( ) ) ;
Surface * surface = mesh - > surfaces [ p_surface ] ;
2019-03-01 20:01:21 +01:00
# ifndef TOOLS_ENABLED
ERR_PRINT ( " OpenGL ES 2.0 does not allow retrieving mesh array data " ) ;
# endif
2018-02-24 14:48:22 +01:00
return surface - > data ;
}
PoolVector < uint8_t > RasterizerStorageGLES2 : : mesh_surface_get_index_array ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , PoolVector < uint8_t > ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , PoolVector < uint8_t > ( ) ) ;
Surface * surface = mesh - > surfaces [ p_surface ] ;
return surface - > index_data ;
}
uint32_t RasterizerStorageGLES2 : : mesh_surface_get_format ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , 0 ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , 0 ) ;
return mesh - > surfaces [ p_surface ] - > format ;
}
VS : : PrimitiveType RasterizerStorageGLES2 : : mesh_surface_get_primitive_type ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , VS : : PRIMITIVE_MAX ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , VS : : PRIMITIVE_MAX ) ;
return mesh - > surfaces [ p_surface ] - > primitive ;
}
AABB RasterizerStorageGLES2 : : mesh_surface_get_aabb ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , AABB ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , AABB ( ) ) ;
return mesh - > surfaces [ p_surface ] - > aabb ;
}
Vector < PoolVector < uint8_t > > RasterizerStorageGLES2 : : mesh_surface_get_blend_shapes ( RID p_mesh , int p_surface ) const {
2019-03-01 20:01:21 +01:00
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , Vector < PoolVector < uint8_t > > ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , Vector < PoolVector < uint8_t > > ( ) ) ;
# ifndef TOOLS_ENABLED
ERR_PRINT ( " OpenGL ES 2.0 does not allow retrieving mesh array data " ) ;
# endif
return mesh - > surfaces [ p_surface ] - > blend_shape_data ;
2018-02-24 14:48:22 +01:00
}
Vector < AABB > RasterizerStorageGLES2 : : mesh_surface_get_skeleton_aabb ( RID p_mesh , int p_surface ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , Vector < AABB > ( ) ) ;
ERR_FAIL_INDEX_V ( p_surface , mesh - > surfaces . size ( ) , Vector < AABB > ( ) ) ;
return mesh - > surfaces [ p_surface ] - > skeleton_bone_aabb ;
}
void RasterizerStorageGLES2 : : mesh_remove_surface ( RID p_mesh , int p_surface ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
ERR_FAIL_INDEX ( p_surface , mesh - > surfaces . size ( ) ) ;
Surface * surface = mesh - > surfaces [ p_surface ] ;
if ( surface - > material . is_valid ( ) ) {
2019-03-01 21:24:57 +01:00
_material_remove_geometry ( surface - > material , mesh - > surfaces [ p_surface ] ) ;
2018-02-24 14:48:22 +01:00
}
glDeleteBuffers ( 1 , & surface - > vertex_id ) ;
if ( surface - > index_id ) {
glDeleteBuffers ( 1 , & surface - > index_id ) ;
}
for ( int i = 0 ; i < surface - > blend_shapes . size ( ) ; i + + ) {
glDeleteBuffers ( 1 , & surface - > blend_shapes [ i ] . vertex_id ) ;
}
info . vertex_mem - = surface - > total_data_size ;
memdelete ( surface ) ;
mesh - > surfaces . remove ( p_surface ) ;
2018-11-14 13:32:39 +01:00
mesh - > instance_change_notify ( true , true ) ;
2018-02-24 14:48:22 +01:00
}
int RasterizerStorageGLES2 : : mesh_get_surface_count ( RID p_mesh ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , 0 ) ;
return mesh - > surfaces . size ( ) ;
}
void RasterizerStorageGLES2 : : mesh_set_custom_aabb ( RID p_mesh , const AABB & p_aabb ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
mesh - > custom_aabb = p_aabb ;
}
AABB RasterizerStorageGLES2 : : mesh_get_custom_aabb ( RID p_mesh ) const {
const Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , AABB ( ) ) ;
return mesh - > custom_aabb ;
}
AABB RasterizerStorageGLES2 : : mesh_get_aabb ( RID p_mesh , RID p_skeleton ) const {
Mesh * mesh = mesh_owner . get ( p_mesh ) ;
ERR_FAIL_COND_V ( ! mesh , AABB ( ) ) ;
if ( mesh - > custom_aabb ! = AABB ( ) )
return mesh - > custom_aabb ;
2019-03-01 21:41:15 +01:00
Skeleton * sk = NULL ;
if ( p_skeleton . is_valid ( ) ) {
sk = skeleton_owner . get ( p_skeleton ) ;
}
2018-02-24 14:48:22 +01:00
AABB aabb ;
2019-03-01 21:41:15 +01:00
if ( sk & & sk - > size ! = 0 ) {
for ( int i = 0 ; i < mesh - > surfaces . size ( ) ; i + + ) {
AABB laabb ;
if ( ( mesh - > surfaces [ i ] - > format & VS : : ARRAY_FORMAT_BONES ) & & mesh - > surfaces [ i ] - > skeleton_bone_aabb . size ( ) ) {
int bs = mesh - > surfaces [ i ] - > skeleton_bone_aabb . size ( ) ;
const AABB * skbones = mesh - > surfaces [ i ] - > skeleton_bone_aabb . ptr ( ) ;
const bool * skused = mesh - > surfaces [ i ] - > skeleton_bone_used . ptr ( ) ;
int sbs = sk - > size ;
ERR_CONTINUE ( bs > sbs ) ;
const float * texture = sk - > bone_data . ptr ( ) ;
bool first = true ;
if ( sk - > use_2d ) {
for ( int j = 0 ; j < bs ; j + + ) {
if ( ! skused [ j ] )
continue ;
int base_ofs = j * 2 * 4 ;
Transform mtx ;
mtx . basis [ 0 ] . x = texture [ base_ofs + 0 ] ;
mtx . basis [ 0 ] . y = texture [ base_ofs + 1 ] ;
mtx . origin . x = texture [ base_ofs + 3 ] ;
2019-03-03 16:23:03 +01:00
base_ofs + = 4 ;
2019-03-01 21:41:15 +01:00
mtx . basis [ 1 ] . x = texture [ base_ofs + 0 ] ;
mtx . basis [ 1 ] . y = texture [ base_ofs + 1 ] ;
mtx . origin . y = texture [ base_ofs + 3 ] ;
AABB baabb = mtx . xform ( skbones [ j ] ) ;
if ( first ) {
laabb = baabb ;
first = false ;
} else {
laabb . merge_with ( baabb ) ;
}
}
} else {
for ( int j = 0 ; j < bs ; j + + ) {
if ( ! skused [ j ] )
continue ;
int base_ofs = j * 3 * 4 ;
Transform mtx ;
mtx . basis [ 0 ] . x = texture [ base_ofs + 0 ] ;
mtx . basis [ 0 ] . y = texture [ base_ofs + 1 ] ;
mtx . basis [ 0 ] . z = texture [ base_ofs + 2 ] ;
mtx . origin . x = texture [ base_ofs + 3 ] ;
2019-03-03 16:23:03 +01:00
base_ofs + = 4 ;
2019-03-01 21:41:15 +01:00
mtx . basis [ 1 ] . x = texture [ base_ofs + 0 ] ;
mtx . basis [ 1 ] . y = texture [ base_ofs + 1 ] ;
mtx . basis [ 1 ] . z = texture [ base_ofs + 2 ] ;
mtx . origin . y = texture [ base_ofs + 3 ] ;
2019-03-03 16:23:03 +01:00
base_ofs + = 4 ;
2019-03-01 21:41:15 +01:00
mtx . basis [ 2 ] . x = texture [ base_ofs + 0 ] ;
mtx . basis [ 2 ] . y = texture [ base_ofs + 1 ] ;
mtx . basis [ 2 ] . z = texture [ base_ofs + 2 ] ;
mtx . origin . z = texture [ base_ofs + 3 ] ;
AABB baabb = mtx . xform ( skbones [ j ] ) ;
if ( first ) {
laabb = baabb ;
first = false ;
} else {
laabb . merge_with ( baabb ) ;
}
}
}
2018-02-24 14:48:22 +01:00
2019-03-01 21:41:15 +01:00
} else {
laabb = mesh - > surfaces [ i ] - > aabb ;
}
if ( i = = 0 )
aabb = laabb ;
else
aabb . merge_with ( laabb ) ;
}
} else {
for ( int i = 0 ; i < mesh - > surfaces . size ( ) ; i + + ) {
if ( i = = 0 )
aabb = mesh - > surfaces [ i ] - > aabb ;
else
aabb . merge_with ( mesh - > surfaces [ i ] - > aabb ) ;
}
2018-02-24 14:48:22 +01:00
}
return aabb ;
}
void RasterizerStorageGLES2 : : mesh_clear ( RID p_mesh ) {
Mesh * mesh = mesh_owner . getornull ( p_mesh ) ;
ERR_FAIL_COND ( ! mesh ) ;
while ( mesh - > surfaces . size ( ) ) {
mesh_remove_surface ( p_mesh , 0 ) ;
}
}
/* MULTIMESH API */
RID RasterizerStorageGLES2 : : multimesh_create ( ) {
MultiMesh * multimesh = memnew ( MultiMesh ) ;
return multimesh_owner . make_rid ( multimesh ) ;
}
void RasterizerStorageGLES2 : : multimesh_allocate ( RID p_multimesh , int p_instances , VS : : MultimeshTransformFormat p_transform_format , VS : : MultimeshColorFormat p_color_format , VS : : MultimeshCustomDataFormat p_data ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
if ( multimesh - > size = = p_instances & & multimesh - > transform_format = = p_transform_format & & multimesh - > color_format = = p_color_format & & multimesh - > custom_data_format = = p_data ) {
return ;
}
multimesh - > size = p_instances ;
multimesh - > color_format = p_color_format ;
multimesh - > transform_format = p_transform_format ;
multimesh - > custom_data_format = p_data ;
if ( multimesh - > size ) {
multimesh - > data . resize ( 0 ) ;
}
if ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_2D ) {
multimesh - > xform_floats = 8 ;
} else {
multimesh - > xform_floats = 12 ;
}
2020-01-13 02:45:06 +01:00
if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_8BIT ) {
2018-02-24 14:48:22 +01:00
multimesh - > color_floats = 1 ;
} else if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_FLOAT ) {
multimesh - > color_floats = 4 ;
2020-01-13 02:45:06 +01:00
} else {
multimesh - > color_floats = 0 ;
2018-02-24 14:48:22 +01:00
}
2020-01-13 02:45:06 +01:00
if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_8BIT ) {
2018-02-24 14:48:22 +01:00
multimesh - > custom_data_floats = 1 ;
} else if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_FLOAT ) {
multimesh - > custom_data_floats = 4 ;
2020-01-13 02:45:06 +01:00
} else {
multimesh - > custom_data_floats = 0 ;
2018-02-24 14:48:22 +01:00
}
int format_floats = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
multimesh - > data . resize ( format_floats * p_instances ) ;
for ( int i = 0 ; i < p_instances * format_floats ; i + = format_floats ) {
int color_from = 0 ;
int custom_data_from = 0 ;
if ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_2D ) {
multimesh - > data . write [ i + 0 ] = 1.0 ;
multimesh - > data . write [ i + 1 ] = 0.0 ;
multimesh - > data . write [ i + 2 ] = 0.0 ;
multimesh - > data . write [ i + 3 ] = 0.0 ;
multimesh - > data . write [ i + 4 ] = 0.0 ;
multimesh - > data . write [ i + 5 ] = 1.0 ;
multimesh - > data . write [ i + 6 ] = 0.0 ;
multimesh - > data . write [ i + 7 ] = 0.0 ;
color_from = 8 ;
custom_data_from = 8 ;
} else {
multimesh - > data . write [ i + 0 ] = 1.0 ;
multimesh - > data . write [ i + 1 ] = 0.0 ;
multimesh - > data . write [ i + 2 ] = 0.0 ;
multimesh - > data . write [ i + 3 ] = 0.0 ;
multimesh - > data . write [ i + 4 ] = 0.0 ;
multimesh - > data . write [ i + 5 ] = 1.0 ;
multimesh - > data . write [ i + 6 ] = 0.0 ;
multimesh - > data . write [ i + 7 ] = 0.0 ;
multimesh - > data . write [ i + 8 ] = 0.0 ;
multimesh - > data . write [ i + 9 ] = 0.0 ;
multimesh - > data . write [ i + 10 ] = 1.0 ;
multimesh - > data . write [ i + 11 ] = 0.0 ;
color_from = 12 ;
custom_data_from = 12 ;
}
if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_8BIT ) {
union {
uint32_t colu ;
float colf ;
} cu ;
cu . colu = 0xFFFFFFFF ;
multimesh - > data . write [ i + color_from + 0 ] = cu . colf ;
custom_data_from = color_from + 1 ;
} else if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_FLOAT ) {
multimesh - > data . write [ i + color_from + 0 ] = 1.0 ;
multimesh - > data . write [ i + color_from + 1 ] = 1.0 ;
multimesh - > data . write [ i + color_from + 2 ] = 1.0 ;
multimesh - > data . write [ i + color_from + 3 ] = 1.0 ;
custom_data_from = color_from + 4 ;
}
if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_8BIT ) {
union {
uint32_t colu ;
float colf ;
} cu ;
cu . colu = 0 ;
multimesh - > data . write [ i + custom_data_from + 0 ] = cu . colf ;
} else if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_FLOAT ) {
multimesh - > data . write [ i + custom_data_from + 0 ] = 0.0 ;
multimesh - > data . write [ i + custom_data_from + 1 ] = 0.0 ;
multimesh - > data . write [ i + custom_data_from + 2 ] = 0.0 ;
multimesh - > data . write [ i + custom_data_from + 3 ] = 0.0 ;
}
}
multimesh - > dirty_aabb = true ;
multimesh - > dirty_data = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
int RasterizerStorageGLES2 : : multimesh_get_instance_count ( RID p_multimesh ) const {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , 0 ) ;
return multimesh - > size ;
}
void RasterizerStorageGLES2 : : multimesh_set_mesh ( RID p_multimesh , RID p_mesh ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
if ( multimesh - > mesh . is_valid ( ) ) {
Mesh * mesh = mesh_owner . getornull ( multimesh - > mesh ) ;
if ( mesh ) {
mesh - > multimeshes . remove ( & multimesh - > mesh_list ) ;
}
}
multimesh - > mesh = p_mesh ;
if ( multimesh - > mesh . is_valid ( ) ) {
Mesh * mesh = mesh_owner . getornull ( multimesh - > mesh ) ;
if ( mesh ) {
mesh - > multimeshes . add ( & multimesh - > mesh_list ) ;
}
}
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
void RasterizerStorageGLES2 : : multimesh_instance_set_transform ( RID p_multimesh , int p_index , const Transform & p_transform ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
ERR_FAIL_INDEX ( p_index , multimesh - > size ) ;
ERR_FAIL_COND ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_2D ) ;
int stride = multimesh - > color_floats + multimesh - > custom_data_floats + multimesh - > xform_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index ] ;
dataptr [ 0 ] = p_transform . basis . elements [ 0 ] [ 0 ] ;
dataptr [ 1 ] = p_transform . basis . elements [ 0 ] [ 1 ] ;
dataptr [ 2 ] = p_transform . basis . elements [ 0 ] [ 2 ] ;
dataptr [ 3 ] = p_transform . origin . x ;
dataptr [ 4 ] = p_transform . basis . elements [ 1 ] [ 0 ] ;
dataptr [ 5 ] = p_transform . basis . elements [ 1 ] [ 1 ] ;
dataptr [ 6 ] = p_transform . basis . elements [ 1 ] [ 2 ] ;
dataptr [ 7 ] = p_transform . origin . y ;
dataptr [ 8 ] = p_transform . basis . elements [ 2 ] [ 0 ] ;
dataptr [ 9 ] = p_transform . basis . elements [ 2 ] [ 1 ] ;
dataptr [ 10 ] = p_transform . basis . elements [ 2 ] [ 2 ] ;
dataptr [ 11 ] = p_transform . origin . z ;
multimesh - > dirty_data = true ;
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
void RasterizerStorageGLES2 : : multimesh_instance_set_transform_2d ( RID p_multimesh , int p_index , const Transform2D & p_transform ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
ERR_FAIL_INDEX ( p_index , multimesh - > size ) ;
ERR_FAIL_COND ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_3D ) ;
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index ] ;
dataptr [ 0 ] = p_transform . elements [ 0 ] [ 0 ] ;
dataptr [ 1 ] = p_transform . elements [ 1 ] [ 0 ] ;
dataptr [ 2 ] = 0 ;
dataptr [ 3 ] = p_transform . elements [ 2 ] [ 0 ] ;
dataptr [ 4 ] = p_transform . elements [ 0 ] [ 1 ] ;
dataptr [ 5 ] = p_transform . elements [ 1 ] [ 1 ] ;
dataptr [ 6 ] = 0 ;
dataptr [ 7 ] = p_transform . elements [ 2 ] [ 1 ] ;
multimesh - > dirty_data = true ;
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
void RasterizerStorageGLES2 : : multimesh_instance_set_color ( RID p_multimesh , int p_index , const Color & p_color ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
ERR_FAIL_INDEX ( p_index , multimesh - > size ) ;
ERR_FAIL_COND ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_NONE ) ;
2020-01-13 02:45:06 +01:00
ERR_FAIL_INDEX ( multimesh - > color_format , VS : : MULTIMESH_COLOR_FLOAT ) ;
2018-02-24 14:48:22 +01:00
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index + multimesh - > xform_floats ] ;
if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_8BIT ) {
uint8_t * data8 = ( uint8_t * ) dataptr ;
data8 [ 0 ] = CLAMP ( p_color . r * 255.0 , 0 , 255 ) ;
data8 [ 1 ] = CLAMP ( p_color . g * 255.0 , 0 , 255 ) ;
data8 [ 2 ] = CLAMP ( p_color . b * 255.0 , 0 , 255 ) ;
data8 [ 3 ] = CLAMP ( p_color . a * 255.0 , 0 , 255 ) ;
} else if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_FLOAT ) {
dataptr [ 0 ] = p_color . r ;
dataptr [ 1 ] = p_color . g ;
dataptr [ 2 ] = p_color . b ;
dataptr [ 3 ] = p_color . a ;
}
multimesh - > dirty_data = true ;
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
void RasterizerStorageGLES2 : : multimesh_instance_set_custom_data ( RID p_multimesh , int p_index , const Color & p_custom_data ) {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
ERR_FAIL_INDEX ( p_index , multimesh - > size ) ;
ERR_FAIL_COND ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_NONE ) ;
2020-01-13 02:45:06 +01:00
ERR_FAIL_INDEX ( multimesh - > custom_data_format , VS : : MULTIMESH_CUSTOM_DATA_FLOAT ) ;
2018-02-24 14:48:22 +01:00
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index + multimesh - > xform_floats + multimesh - > color_floats ] ;
if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_8BIT ) {
uint8_t * data8 = ( uint8_t * ) dataptr ;
data8 [ 0 ] = CLAMP ( p_custom_data . r * 255.0 , 0 , 255 ) ;
data8 [ 1 ] = CLAMP ( p_custom_data . g * 255.0 , 0 , 255 ) ;
data8 [ 2 ] = CLAMP ( p_custom_data . b * 255.0 , 0 , 255 ) ;
data8 [ 3 ] = CLAMP ( p_custom_data . a * 255.0 , 0 , 255 ) ;
} else if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_FLOAT ) {
dataptr [ 0 ] = p_custom_data . r ;
dataptr [ 1 ] = p_custom_data . g ;
dataptr [ 2 ] = p_custom_data . b ;
dataptr [ 3 ] = p_custom_data . a ;
}
multimesh - > dirty_data = true ;
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
2018-07-07 01:21:13 +02:00
}
2017-12-04 13:41:34 +01:00
RID RasterizerStorageGLES2 : : multimesh_get_mesh ( RID p_multimesh ) const {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , RID ( ) ) ;
return multimesh - > mesh ;
2017-12-04 13:41:34 +01:00
}
Transform RasterizerStorageGLES2 : : multimesh_instance_get_transform ( RID p_multimesh , int p_index ) const {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , Transform ( ) ) ;
ERR_FAIL_INDEX_V ( p_index , multimesh - > size , Transform ( ) ) ;
ERR_FAIL_COND_V ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_2D , Transform ( ) ) ;
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index ] ;
Transform xform ;
xform . basis . elements [ 0 ] [ 0 ] = dataptr [ 0 ] ;
xform . basis . elements [ 0 ] [ 1 ] = dataptr [ 1 ] ;
xform . basis . elements [ 0 ] [ 2 ] = dataptr [ 2 ] ;
xform . origin . x = dataptr [ 3 ] ;
xform . basis . elements [ 1 ] [ 0 ] = dataptr [ 4 ] ;
xform . basis . elements [ 1 ] [ 1 ] = dataptr [ 5 ] ;
xform . basis . elements [ 1 ] [ 2 ] = dataptr [ 6 ] ;
xform . origin . y = dataptr [ 7 ] ;
xform . basis . elements [ 2 ] [ 0 ] = dataptr [ 8 ] ;
xform . basis . elements [ 2 ] [ 1 ] = dataptr [ 9 ] ;
xform . basis . elements [ 2 ] [ 2 ] = dataptr [ 10 ] ;
xform . origin . z = dataptr [ 11 ] ;
return xform ;
2017-12-04 13:41:34 +01:00
}
2018-02-24 14:48:22 +01:00
Transform2D RasterizerStorageGLES2 : : multimesh_instance_get_transform_2d ( RID p_multimesh , int p_index ) const {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , Transform2D ( ) ) ;
ERR_FAIL_INDEX_V ( p_index , multimesh - > size , Transform2D ( ) ) ;
ERR_FAIL_COND_V ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_3D , Transform2D ( ) ) ;
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index ] ;
Transform2D xform ;
xform . elements [ 0 ] [ 0 ] = dataptr [ 0 ] ;
xform . elements [ 1 ] [ 0 ] = dataptr [ 1 ] ;
xform . elements [ 2 ] [ 0 ] = dataptr [ 3 ] ;
xform . elements [ 0 ] [ 1 ] = dataptr [ 4 ] ;
xform . elements [ 1 ] [ 1 ] = dataptr [ 5 ] ;
xform . elements [ 2 ] [ 1 ] = dataptr [ 7 ] ;
return xform ;
}
Color RasterizerStorageGLES2 : : multimesh_instance_get_color ( RID p_multimesh , int p_index ) const {
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , Color ( ) ) ;
ERR_FAIL_INDEX_V ( p_index , multimesh - > size , Color ( ) ) ;
ERR_FAIL_COND_V ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_NONE , Color ( ) ) ;
2020-01-13 02:45:06 +01:00
ERR_FAIL_INDEX_V ( multimesh - > color_format , VS : : MULTIMESH_COLOR_FLOAT , Color ( ) ) ;
2018-02-24 14:48:22 +01:00
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index + multimesh - > xform_floats ] ;
if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_8BIT ) {
union {
uint32_t colu ;
float colf ;
} cu ;
cu . colf = dataptr [ 0 ] ;
return Color : : hex ( BSWAP32 ( cu . colu ) ) ;
} else if ( multimesh - > color_format = = VS : : MULTIMESH_COLOR_FLOAT ) {
Color c ;
c . r = dataptr [ 0 ] ;
c . g = dataptr [ 1 ] ;
c . b = dataptr [ 2 ] ;
c . a = dataptr [ 3 ] ;
return c ;
}
2017-12-04 13:41:34 +01:00
return Color ( ) ;
}
2018-07-07 01:21:13 +02:00
Color RasterizerStorageGLES2 : : multimesh_instance_get_custom_data ( RID p_multimesh , int p_index ) const {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , Color ( ) ) ;
ERR_FAIL_INDEX_V ( p_index , multimesh - > size , Color ( ) ) ;
ERR_FAIL_COND_V ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_NONE , Color ( ) ) ;
2020-01-13 02:45:06 +01:00
ERR_FAIL_INDEX_V ( multimesh - > custom_data_format , VS : : MULTIMESH_CUSTOM_DATA_FLOAT , Color ( ) ) ;
2018-02-24 14:48:22 +01:00
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
float * dataptr = & multimesh - > data . write [ stride * p_index + multimesh - > xform_floats + multimesh - > color_floats ] ;
if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_8BIT ) {
union {
uint32_t colu ;
float colf ;
} cu ;
cu . colf = dataptr [ 0 ] ;
return Color : : hex ( BSWAP32 ( cu . colu ) ) ;
} else if ( multimesh - > custom_data_format = = VS : : MULTIMESH_CUSTOM_DATA_FLOAT ) {
Color c ;
c . r = dataptr [ 0 ] ;
c . g = dataptr [ 1 ] ;
c . b = dataptr [ 2 ] ;
c . a = dataptr [ 3 ] ;
return c ;
}
2018-07-07 01:21:13 +02:00
return Color ( ) ;
}
void RasterizerStorageGLES2 : : multimesh_set_as_bulk_array ( RID p_multimesh , const PoolVector < float > & p_array ) {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
2019-10-28 08:07:29 +01:00
ERR_FAIL_COND ( ! multimesh - > data . ptr ( ) ) ;
2018-02-24 14:48:22 +01:00
int dsize = multimesh - > data . size ( ) ;
ERR_FAIL_COND ( dsize ! = p_array . size ( ) ) ;
PoolVector < float > : : Read r = p_array . read ( ) ;
2019-10-28 08:07:29 +01:00
ERR_FAIL_COND ( ! r . ptr ( ) ) ;
2018-02-24 14:48:22 +01:00
copymem ( multimesh - > data . ptrw ( ) , r . ptr ( ) , dsize * sizeof ( float ) ) ;
multimesh - > dirty_data = true ;
multimesh - > dirty_aabb = true ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
2018-07-07 01:21:13 +02:00
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : multimesh_set_visible_instances ( RID p_multimesh , int p_visible ) {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND ( ! multimesh ) ;
multimesh - > visible_instances = p_visible ;
2017-12-04 13:41:34 +01:00
}
int RasterizerStorageGLES2 : : multimesh_get_visible_instances ( RID p_multimesh ) const {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , - 1 ) ;
return multimesh - > visible_instances ;
2017-12-04 13:41:34 +01:00
}
AABB RasterizerStorageGLES2 : : multimesh_get_aabb ( RID p_multimesh ) const {
2018-02-24 14:48:22 +01:00
MultiMesh * multimesh = multimesh_owner . getornull ( p_multimesh ) ;
ERR_FAIL_COND_V ( ! multimesh , AABB ( ) ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
const_cast < RasterizerStorageGLES2 * > ( this ) - > update_dirty_multimeshes ( ) ;
return multimesh - > aabb ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : update_dirty_multimeshes ( ) {
2018-02-24 14:48:22 +01:00
while ( multimesh_update_list . first ( ) ) {
MultiMesh * multimesh = multimesh_update_list . first ( ) - > self ( ) ;
if ( multimesh - > size & & multimesh - > dirty_aabb ) {
AABB mesh_aabb ;
if ( multimesh - > mesh . is_valid ( ) ) {
mesh_aabb = mesh_get_aabb ( multimesh - > mesh , RID ( ) ) ;
}
2018-09-29 18:49:34 +02:00
mesh_aabb . size + = Vector3 ( 0.001 , 0.001 , 0.001 ) ; //in case mesh is empty in one of the sides
2018-02-24 14:48:22 +01:00
int stride = multimesh - > color_floats + multimesh - > xform_floats + multimesh - > custom_data_floats ;
int count = multimesh - > data . size ( ) ;
float * data = multimesh - > data . ptrw ( ) ;
AABB aabb ;
if ( multimesh - > transform_format = = VS : : MULTIMESH_TRANSFORM_2D ) {
for ( int i = 0 ; i < count ; i + = stride ) {
float * dataptr = & data [ i ] ;
Transform xform ;
xform . basis [ 0 ] [ 0 ] = dataptr [ 0 ] ;
xform . basis [ 0 ] [ 1 ] = dataptr [ 1 ] ;
xform . origin [ 0 ] = dataptr [ 3 ] ;
xform . basis [ 1 ] [ 0 ] = dataptr [ 4 ] ;
xform . basis [ 1 ] [ 1 ] = dataptr [ 5 ] ;
xform . origin [ 1 ] = dataptr [ 7 ] ;
AABB laabb = xform . xform ( mesh_aabb ) ;
if ( i = = 0 ) {
aabb = laabb ;
} else {
aabb . merge_with ( laabb ) ;
}
}
} else {
for ( int i = 0 ; i < count ; i + = stride ) {
float * dataptr = & data [ i ] ;
Transform xform ;
xform . basis . elements [ 0 ] [ 0 ] = dataptr [ 0 ] ;
xform . basis . elements [ 0 ] [ 1 ] = dataptr [ 1 ] ;
xform . basis . elements [ 0 ] [ 2 ] = dataptr [ 2 ] ;
xform . origin . x = dataptr [ 3 ] ;
xform . basis . elements [ 1 ] [ 0 ] = dataptr [ 4 ] ;
xform . basis . elements [ 1 ] [ 1 ] = dataptr [ 5 ] ;
xform . basis . elements [ 1 ] [ 2 ] = dataptr [ 6 ] ;
xform . origin . y = dataptr [ 7 ] ;
xform . basis . elements [ 2 ] [ 0 ] = dataptr [ 8 ] ;
xform . basis . elements [ 2 ] [ 1 ] = dataptr [ 9 ] ;
xform . basis . elements [ 2 ] [ 2 ] = dataptr [ 10 ] ;
xform . origin . z = dataptr [ 11 ] ;
AABB laabb = xform . xform ( mesh_aabb ) ;
if ( i = = 0 ) {
aabb = laabb ;
} else {
aabb . merge_with ( laabb ) ;
}
}
}
multimesh - > aabb = aabb ;
}
multimesh - > dirty_aabb = false ;
multimesh - > dirty_data = false ;
2018-11-14 13:32:39 +01:00
multimesh - > instance_change_notify ( true , false ) ;
2018-02-24 14:48:22 +01:00
multimesh_update_list . remove ( multimesh_update_list . first ( ) ) ;
}
2017-12-04 13:41:34 +01:00
}
/* IMMEDIATE API */
RID RasterizerStorageGLES2 : : immediate_create ( ) {
2018-08-13 16:16:23 +02:00
Immediate * im = memnew ( Immediate ) ;
return immediate_owner . make_rid ( im ) ;
2017-12-04 13:41:34 +01:00
}
2018-08-13 16:16:23 +02:00
void RasterizerStorageGLES2 : : immediate_begin ( RID p_immediate , VS : : PrimitiveType p_primitive , RID p_texture ) {
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( im - > building ) ;
Immediate : : Chunk ic ;
ic . texture = p_texture ;
ic . primitive = p_primitive ;
im - > chunks . push_back ( ic ) ;
im - > mask = 0 ;
im - > building = true ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_vertex ( RID p_immediate , const Vector3 & p_vertex ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
Immediate : : Chunk * c = & im - > chunks . back ( ) - > get ( ) ;
if ( c - > vertices . empty ( ) & & im - > chunks . size ( ) = = 1 ) {
im - > aabb . position = p_vertex ;
im - > aabb . size = Vector3 ( ) ;
} else {
im - > aabb . expand_to ( p_vertex ) ;
}
if ( im - > mask & VS : : ARRAY_FORMAT_NORMAL )
c - > normals . push_back ( chunk_normal ) ;
if ( im - > mask & VS : : ARRAY_FORMAT_TANGENT )
c - > tangents . push_back ( chunk_tangent ) ;
if ( im - > mask & VS : : ARRAY_FORMAT_COLOR )
c - > colors . push_back ( chunk_color ) ;
if ( im - > mask & VS : : ARRAY_FORMAT_TEX_UV )
c - > uvs . push_back ( chunk_uv ) ;
if ( im - > mask & VS : : ARRAY_FORMAT_TEX_UV2 )
c - > uv2s . push_back ( chunk_uv2 ) ;
im - > mask | = VS : : ARRAY_FORMAT_VERTEX ;
c - > vertices . push_back ( p_vertex ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_normal ( RID p_immediate , const Vector3 & p_normal ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > mask | = VS : : ARRAY_FORMAT_NORMAL ;
chunk_normal = p_normal ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_tangent ( RID p_immediate , const Plane & p_tangent ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > mask | = VS : : ARRAY_FORMAT_TANGENT ;
chunk_tangent = p_tangent ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_color ( RID p_immediate , const Color & p_color ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > mask | = VS : : ARRAY_FORMAT_COLOR ;
chunk_color = p_color ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_uv ( RID p_immediate , const Vector2 & tex_uv ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > mask | = VS : : ARRAY_FORMAT_TEX_UV ;
chunk_uv = tex_uv ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_uv2 ( RID p_immediate , const Vector2 & tex_uv ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > mask | = VS : : ARRAY_FORMAT_TEX_UV2 ;
chunk_uv2 = tex_uv ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_end ( RID p_immediate ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( ! im - > building ) ;
im - > building = false ;
2018-11-14 13:32:39 +01:00
im - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_clear ( RID p_immediate ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
ERR_FAIL_COND ( im - > building ) ;
im - > chunks . clear ( ) ;
2018-11-14 13:32:39 +01:00
im - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
AABB RasterizerStorageGLES2 : : immediate_get_aabb ( RID p_immediate ) const {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND_V ( ! im , AABB ( ) ) ;
return im - > aabb ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : immediate_set_material ( RID p_immediate , RID p_material ) {
2018-08-13 16:16:23 +02:00
Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND ( ! im ) ;
im - > material = p_material ;
2018-11-14 13:32:39 +01:00
im - > instance_change_notify ( false , true ) ;
2017-12-04 13:41:34 +01:00
}
RID RasterizerStorageGLES2 : : immediate_get_material ( RID p_immediate ) const {
2018-08-13 16:16:23 +02:00
const Immediate * im = immediate_owner . get ( p_immediate ) ;
ERR_FAIL_COND_V ( ! im , RID ( ) ) ;
return im - > material ;
2017-12-04 13:41:34 +01:00
}
/* SKELETON API */
RID RasterizerStorageGLES2 : : skeleton_create ( ) {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = memnew ( Skeleton ) ;
2019-08-19 06:50:33 +02:00
glGenTextures ( 1 , & skeleton - > tex_id ) ;
2018-02-24 14:48:22 +01:00
return skeleton_owner . make_rid ( skeleton ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : skeleton_allocate ( RID p_skeleton , int p_bones , bool p_2d_skeleton ) {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
ERR_FAIL_COND ( p_bones < 0 ) ;
if ( skeleton - > size = = p_bones & & skeleton - > use_2d = = p_2d_skeleton ) {
return ;
}
skeleton - > size = p_bones ;
skeleton - > use_2d = p_2d_skeleton ;
2019-09-20 10:45:51 +02:00
if ( ! config . use_skeleton_software ) {
2018-02-24 14:48:22 +01:00
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , skeleton - > tex_id ) ;
2018-08-22 18:20:18 +02:00
# ifdef GLES_OVER_GL
2018-12-28 00:39:00 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA32F , p_bones * ( skeleton - > use_2d ? 2 : 3 ) , 1 , 0 , GL_RGBA , GL_FLOAT , NULL ) ;
2018-08-22 18:20:18 +02:00
# else
2018-12-28 00:39:00 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , p_bones * ( skeleton - > use_2d ? 2 : 3 ) , 1 , 0 , GL_RGBA , GL_FLOAT , NULL ) ;
2018-08-22 18:20:18 +02:00
# endif
2018-02-24 14:48:22 +01:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
}
if ( skeleton - > use_2d ) {
skeleton - > bone_data . resize ( p_bones * 4 * 2 ) ;
} else {
skeleton - > bone_data . resize ( p_bones * 4 * 3 ) ;
}
2017-12-04 13:41:34 +01:00
}
int RasterizerStorageGLES2 : : skeleton_get_bone_count ( RID p_skeleton ) const {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND_V ( ! skeleton , 0 ) ;
return skeleton - > size ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : skeleton_bone_set_transform ( RID p_skeleton , int p_bone , const Transform & p_transform ) {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
ERR_FAIL_INDEX ( p_bone , skeleton - > size ) ;
ERR_FAIL_COND ( skeleton - > use_2d ) ;
float * bone_data = skeleton - > bone_data . ptrw ( ) ;
int base_offset = p_bone * 4 * 3 ;
bone_data [ base_offset + 0 ] = p_transform . basis [ 0 ] . x ;
bone_data [ base_offset + 1 ] = p_transform . basis [ 0 ] . y ;
bone_data [ base_offset + 2 ] = p_transform . basis [ 0 ] . z ;
bone_data [ base_offset + 3 ] = p_transform . origin . x ;
bone_data [ base_offset + 4 ] = p_transform . basis [ 1 ] . x ;
bone_data [ base_offset + 5 ] = p_transform . basis [ 1 ] . y ;
bone_data [ base_offset + 6 ] = p_transform . basis [ 1 ] . z ;
bone_data [ base_offset + 7 ] = p_transform . origin . y ;
bone_data [ base_offset + 8 ] = p_transform . basis [ 2 ] . x ;
bone_data [ base_offset + 9 ] = p_transform . basis [ 2 ] . y ;
bone_data [ base_offset + 10 ] = p_transform . basis [ 2 ] . z ;
bone_data [ base_offset + 11 ] = p_transform . origin . z ;
if ( ! skeleton - > update_list . in_list ( ) ) {
skeleton_update_list . add ( & skeleton - > update_list ) ;
}
2017-12-04 13:41:34 +01:00
}
Transform RasterizerStorageGLES2 : : skeleton_bone_get_transform ( RID p_skeleton , int p_bone ) const {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND_V ( ! skeleton , Transform ( ) ) ;
ERR_FAIL_INDEX_V ( p_bone , skeleton - > size , Transform ( ) ) ;
ERR_FAIL_COND_V ( skeleton - > use_2d , Transform ( ) ) ;
const float * bone_data = skeleton - > bone_data . ptr ( ) ;
Transform ret ;
int base_offset = p_bone * 4 * 3 ;
ret . basis [ 0 ] . x = bone_data [ base_offset + 0 ] ;
ret . basis [ 0 ] . y = bone_data [ base_offset + 1 ] ;
ret . basis [ 0 ] . z = bone_data [ base_offset + 2 ] ;
ret . origin . x = bone_data [ base_offset + 3 ] ;
ret . basis [ 1 ] . x = bone_data [ base_offset + 4 ] ;
ret . basis [ 1 ] . y = bone_data [ base_offset + 5 ] ;
ret . basis [ 1 ] . z = bone_data [ base_offset + 6 ] ;
ret . origin . y = bone_data [ base_offset + 7 ] ;
ret . basis [ 2 ] . x = bone_data [ base_offset + 8 ] ;
ret . basis [ 2 ] . y = bone_data [ base_offset + 9 ] ;
ret . basis [ 2 ] . z = bone_data [ base_offset + 10 ] ;
ret . origin . z = bone_data [ base_offset + 11 ] ;
return ret ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : skeleton_bone_set_transform_2d ( RID p_skeleton , int p_bone , const Transform2D & p_transform ) {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
ERR_FAIL_INDEX ( p_bone , skeleton - > size ) ;
ERR_FAIL_COND ( ! skeleton - > use_2d ) ;
float * bone_data = skeleton - > bone_data . ptrw ( ) ;
int base_offset = p_bone * 4 * 2 ;
bone_data [ base_offset + 0 ] = p_transform [ 0 ] [ 0 ] ;
bone_data [ base_offset + 1 ] = p_transform [ 1 ] [ 0 ] ;
bone_data [ base_offset + 2 ] = 0 ;
bone_data [ base_offset + 3 ] = p_transform [ 2 ] [ 0 ] ;
bone_data [ base_offset + 4 ] = p_transform [ 0 ] [ 1 ] ;
bone_data [ base_offset + 5 ] = p_transform [ 1 ] [ 1 ] ;
bone_data [ base_offset + 6 ] = 0 ;
bone_data [ base_offset + 7 ] = p_transform [ 2 ] [ 1 ] ;
if ( ! skeleton - > update_list . in_list ( ) ) {
skeleton_update_list . add ( & skeleton - > update_list ) ;
}
2017-12-04 13:41:34 +01:00
}
Transform2D RasterizerStorageGLES2 : : skeleton_bone_get_transform_2d ( RID p_skeleton , int p_bone ) const {
2018-02-24 14:48:22 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND_V ( ! skeleton , Transform2D ( ) ) ;
ERR_FAIL_INDEX_V ( p_bone , skeleton - > size , Transform2D ( ) ) ;
ERR_FAIL_COND_V ( ! skeleton - > use_2d , Transform2D ( ) ) ;
const float * bone_data = skeleton - > bone_data . ptr ( ) ;
Transform2D ret ;
int base_offset = p_bone * 4 * 2 ;
ret [ 0 ] [ 0 ] = bone_data [ base_offset + 0 ] ;
ret [ 1 ] [ 0 ] = bone_data [ base_offset + 1 ] ;
ret [ 2 ] [ 0 ] = bone_data [ base_offset + 3 ] ;
ret [ 0 ] [ 1 ] = bone_data [ base_offset + 4 ] ;
ret [ 1 ] [ 1 ] = bone_data [ base_offset + 5 ] ;
ret [ 2 ] [ 1 ] = bone_data [ base_offset + 7 ] ;
return ret ;
2017-12-04 13:41:34 +01:00
}
2018-05-03 22:29:15 +02:00
void RasterizerStorageGLES2 : : skeleton_set_base_transform_2d ( RID p_skeleton , const Transform2D & p_base_transform ) {
2018-12-28 00:39:00 +01:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
skeleton - > base_transform_2d = p_base_transform ;
2018-05-03 22:29:15 +02:00
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : _update_skeleton_transform_buffer ( const PoolVector < float > & p_data , size_t p_size ) {
glBindBuffer ( GL_ARRAY_BUFFER , resources . skeleton_transform_buffer ) ;
if ( p_size > resources . skeleton_transform_buffer_size ) {
// new requested buffer is bigger, so resizing the GPU buffer
resources . skeleton_transform_buffer_size = p_size ;
glBufferData ( GL_ARRAY_BUFFER , p_size * sizeof ( float ) , p_data . read ( ) . ptr ( ) , GL_DYNAMIC_DRAW ) ;
} else {
glBufferSubData ( GL_ARRAY_BUFFER , 0 , p_size * sizeof ( float ) , p_data . read ( ) . ptr ( ) ) ;
}
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : update_dirty_skeletons ( ) {
2018-02-24 14:48:22 +01:00
2019-09-20 10:45:51 +02:00
if ( config . use_skeleton_software )
2018-02-24 14:48:22 +01:00
return ;
glActiveTexture ( GL_TEXTURE0 ) ;
while ( skeleton_update_list . first ( ) ) {
Skeleton * skeleton = skeleton_update_list . first ( ) - > self ( ) ;
if ( skeleton - > size ) {
glBindTexture ( GL_TEXTURE_2D , skeleton - > tex_id ) ;
2018-12-28 00:39:00 +01:00
glTexSubImage2D ( GL_TEXTURE_2D , 0 , 0 , 0 , skeleton - > size * ( skeleton - > use_2d ? 2 : 3 ) , 1 , GL_RGBA , GL_FLOAT , skeleton - > bone_data . ptr ( ) ) ;
2018-02-24 14:48:22 +01:00
}
for ( Set < RasterizerScene : : InstanceBase * > : : Element * E = skeleton - > instances . front ( ) ; E ; E = E - > next ( ) ) {
2018-11-14 13:32:39 +01:00
E - > get ( ) - > base_changed ( true , false ) ;
2018-02-24 14:48:22 +01:00
}
skeleton_update_list . remove ( skeleton_update_list . first ( ) ) ;
}
2017-12-04 13:41:34 +01:00
}
/* Light API */
RID RasterizerStorageGLES2 : : light_create ( VS : : LightType p_type ) {
2018-02-24 14:48:22 +01:00
Light * light = memnew ( Light ) ;
light - > type = p_type ;
light - > param [ VS : : LIGHT_PARAM_ENERGY ] = 1.0 ;
light - > param [ VS : : LIGHT_PARAM_INDIRECT_ENERGY ] = 1.0 ;
light - > param [ VS : : LIGHT_PARAM_SPECULAR ] = 0.5 ;
light - > param [ VS : : LIGHT_PARAM_RANGE ] = 1.0 ;
light - > param [ VS : : LIGHT_PARAM_SPOT_ANGLE ] = 45 ;
light - > param [ VS : : LIGHT_PARAM_CONTACT_SHADOW_SIZE ] = 45 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_MAX_DISTANCE ] = 0 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET ] = 0.1 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET ] = 0.3 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET ] = 0.6 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_NORMAL_BIAS ] = 0.1 ;
light - > param [ VS : : LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE ] = 0.1 ;
light - > color = Color ( 1 , 1 , 1 , 1 ) ;
light - > shadow = false ;
light - > negative = false ;
light - > cull_mask = 0xFFFFFFFF ;
light - > directional_shadow_mode = VS : : LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL ;
light - > omni_shadow_mode = VS : : LIGHT_OMNI_SHADOW_DUAL_PARABOLOID ;
light - > omni_shadow_detail = VS : : LIGHT_OMNI_SHADOW_DETAIL_VERTICAL ;
light - > directional_blend_splits = false ;
light - > directional_range_mode = VS : : LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE ;
light - > reverse_cull = false ;
2019-04-23 11:36:36 +02:00
light - > use_gi = true ;
2018-02-24 14:48:22 +01:00
light - > version = 0 ;
return light_owner . make_rid ( light ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_color ( RID p_light , const Color & p_color ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > color = p_color ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_param ( RID p_light , VS : : LightParam p_param , float p_value ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
ERR_FAIL_INDEX ( p_param , VS : : LIGHT_PARAM_MAX ) ;
switch ( p_param ) {
case VS : : LIGHT_PARAM_RANGE :
case VS : : LIGHT_PARAM_SPOT_ANGLE :
case VS : : LIGHT_PARAM_SHADOW_MAX_DISTANCE :
case VS : : LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET :
case VS : : LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET :
case VS : : LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET :
case VS : : LIGHT_PARAM_SHADOW_NORMAL_BIAS :
case VS : : LIGHT_PARAM_SHADOW_BIAS : {
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2018-02-24 14:48:22 +01:00
} break ;
2019-04-08 11:53:57 +02:00
default : {
}
2018-02-24 14:48:22 +01:00
}
light - > param [ p_param ] = p_value ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_shadow ( RID p_light , bool p_enabled ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > shadow = p_enabled ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_shadow_color ( RID p_light , const Color & p_color ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > shadow_color = p_color ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_projector ( RID p_light , RID p_texture ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > projector = p_texture ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_negative ( RID p_light , bool p_enable ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > negative = p_enable ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_cull_mask ( RID p_light , uint32_t p_mask ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > cull_mask = p_mask ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_set_reverse_cull_face_mode ( RID p_light , bool p_enabled ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > reverse_cull = p_enabled ;
2018-09-26 21:49:24 +02:00
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
2019-04-23 11:36:36 +02:00
void RasterizerStorageGLES2 : : light_set_use_gi ( RID p_light , bool p_enabled ) {
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > use_gi = p_enabled ;
light - > version + + ;
light - > instance_change_notify ( true , false ) ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : light_omni_set_shadow_mode ( RID p_light , VS : : LightOmniShadowMode p_mode ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > omni_shadow_mode = p_mode ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
VS : : LightOmniShadowMode RasterizerStorageGLES2 : : light_omni_get_shadow_mode ( RID p_light ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , VS : : LIGHT_OMNI_SHADOW_CUBE ) ;
return light - > omni_shadow_mode ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_omni_set_shadow_detail ( RID p_light , VS : : LightOmniShadowDetail p_detail ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > omni_shadow_detail = p_detail ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_directional_set_shadow_mode ( RID p_light , VS : : LightDirectionalShadowMode p_mode ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > directional_shadow_mode = p_mode ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_directional_set_blend_splits ( RID p_light , bool p_enable ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > directional_blend_splits = p_enable ;
light - > version + + ;
2018-11-14 13:32:39 +01:00
light - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : light_directional_get_blend_splits ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , false ) ;
return light - > directional_blend_splits ;
2017-12-04 13:41:34 +01:00
}
VS : : LightDirectionalShadowMode RasterizerStorageGLES2 : : light_directional_get_shadow_mode ( RID p_light ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , VS : : LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL ) ;
return light - > directional_shadow_mode ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : light_directional_set_shadow_depth_range_mode ( RID p_light , VS : : LightDirectionalShadowDepthRangeMode p_range_mode ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND ( ! light ) ;
light - > directional_range_mode = p_range_mode ;
2017-12-04 13:41:34 +01:00
}
VS : : LightDirectionalShadowDepthRangeMode RasterizerStorageGLES2 : : light_directional_get_shadow_depth_range_mode ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , VS : : LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE ) ;
return light - > directional_range_mode ;
2017-12-04 13:41:34 +01:00
}
VS : : LightType RasterizerStorageGLES2 : : light_get_type ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , VS : : LIGHT_DIRECTIONAL ) ;
return light - > type ;
2017-12-04 13:41:34 +01:00
}
float RasterizerStorageGLES2 : : light_get_param ( RID p_light , VS : : LightParam p_param ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , 0.0 ) ;
ERR_FAIL_INDEX_V ( p_param , VS : : LIGHT_PARAM_MAX , 0.0 ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
return light - > param [ p_param ] ;
2017-12-04 13:41:34 +01:00
}
Color RasterizerStorageGLES2 : : light_get_color ( RID p_light ) {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , Color ( ) ) ;
return light - > color ;
2017-12-04 13:41:34 +01:00
}
2019-04-23 11:36:36 +02:00
bool RasterizerStorageGLES2 : : light_get_use_gi ( RID p_light ) {
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , false ) ;
return light - > use_gi ;
}
2017-12-04 13:41:34 +01:00
bool RasterizerStorageGLES2 : : light_has_shadow ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , false ) ;
2017-12-04 13:41:34 +01:00
2018-02-24 14:48:22 +01:00
return light - > shadow ;
2017-12-04 13:41:34 +01:00
}
uint64_t RasterizerStorageGLES2 : : light_get_version ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , 0 ) ;
return light - > version ;
2017-12-04 13:41:34 +01:00
}
AABB RasterizerStorageGLES2 : : light_get_aabb ( RID p_light ) const {
2018-02-24 14:48:22 +01:00
Light * light = light_owner . getornull ( p_light ) ;
ERR_FAIL_COND_V ( ! light , AABB ( ) ) ;
switch ( light - > type ) {
case VS : : LIGHT_SPOT : {
float len = light - > param [ VS : : LIGHT_PARAM_RANGE ] ;
float size = Math : : tan ( Math : : deg2rad ( light - > param [ VS : : LIGHT_PARAM_SPOT_ANGLE ] ) ) * len ;
return AABB ( Vector3 ( - size , - size , - len ) , Vector3 ( size * 2 , size * 2 , len ) ) ;
2019-07-20 08:09:57 +02:00
} ;
2018-02-24 14:48:22 +01:00
case VS : : LIGHT_OMNI : {
float r = light - > param [ VS : : LIGHT_PARAM_RANGE ] ;
return AABB ( - Vector3 ( r , r , r ) , Vector3 ( r , r , r ) * 2 ) ;
2019-07-20 08:09:57 +02:00
} ;
2018-02-24 14:48:22 +01:00
case VS : : LIGHT_DIRECTIONAL : {
return AABB ( ) ;
2019-07-20 08:09:57 +02:00
} ;
2018-02-24 14:48:22 +01:00
}
ERR_FAIL_V ( AABB ( ) ) ;
2017-12-04 13:41:34 +01:00
}
/* PROBE API */
RID RasterizerStorageGLES2 : : reflection_probe_create ( ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = memnew ( ReflectionProbe ) ;
reflection_probe - > intensity = 1.0 ;
reflection_probe - > interior_ambient = Color ( ) ;
reflection_probe - > interior_ambient_energy = 1.0 ;
2019-02-26 01:46:24 +01:00
reflection_probe - > interior_ambient_probe_contrib = 0.0 ;
2018-09-28 21:40:20 +02:00
reflection_probe - > max_distance = 0 ;
reflection_probe - > extents = Vector3 ( 1 , 1 , 1 ) ;
reflection_probe - > origin_offset = Vector3 ( 0 , 0 , 0 ) ;
reflection_probe - > interior = false ;
reflection_probe - > box_projection = false ;
reflection_probe - > enable_shadows = false ;
reflection_probe - > cull_mask = ( 1 < < 20 ) - 1 ;
reflection_probe - > update_mode = VS : : REFLECTION_PROBE_UPDATE_ONCE ;
reflection_probe - > resolution = 128 ;
return reflection_probe_owner . make_rid ( reflection_probe ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_update_mode ( RID p_probe , VS : : ReflectionProbeUpdateMode p_mode ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > update_mode = p_mode ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_intensity ( RID p_probe , float p_intensity ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > intensity = p_intensity ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_interior_ambient ( RID p_probe , const Color & p_ambient ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > interior_ambient = p_ambient ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_interior_ambient_energy ( RID p_probe , float p_energy ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > interior_ambient_energy = p_energy ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_interior_ambient_probe_contribution ( RID p_probe , float p_contrib ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > interior_ambient_probe_contrib = p_contrib ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_max_distance ( RID p_probe , float p_distance ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > max_distance = p_distance ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
2018-09-28 21:40:20 +02:00
void RasterizerStorageGLES2 : : reflection_probe_set_extents ( RID p_probe , const Vector3 & p_extents ) {
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
2017-12-04 13:41:34 +01:00
2018-09-28 21:40:20 +02:00
reflection_probe - > extents = p_extents ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2018-09-28 21:40:20 +02:00
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : reflection_probe_set_origin_offset ( RID p_probe , const Vector3 & p_offset ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > origin_offset = p_offset ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_as_interior ( RID p_probe , bool p_enable ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > interior = p_enable ;
2019-02-26 01:46:24 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2018-09-28 21:40:20 +02:00
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : reflection_probe_set_enable_box_projection ( RID p_probe , bool p_enable ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > box_projection = p_enable ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_enable_shadows ( RID p_probe , bool p_enable ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > enable_shadows = p_enable ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2018-09-28 21:40:20 +02:00
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : reflection_probe_set_cull_mask ( RID p_probe , uint32_t p_layers ) {
2018-09-28 21:40:20 +02:00
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > cull_mask = p_layers ;
2018-11-14 13:32:39 +01:00
reflection_probe - > instance_change_notify ( true , false ) ;
2018-09-28 21:40:20 +02:00
}
void RasterizerStorageGLES2 : : reflection_probe_set_resolution ( RID p_probe , int p_resolution ) {
ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND ( ! reflection_probe ) ;
reflection_probe - > resolution = p_resolution ;
2017-12-04 13:41:34 +01:00
}
AABB RasterizerStorageGLES2 : : reflection_probe_get_aabb ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , AABB ( ) ) ;
AABB aabb ;
aabb . position = - reflection_probe - > extents ;
aabb . size = reflection_probe - > extents * 2.0 ;
return aabb ;
2017-12-04 13:41:34 +01:00
}
VS : : ReflectionProbeUpdateMode RasterizerStorageGLES2 : : reflection_probe_get_update_mode ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , VS : : REFLECTION_PROBE_UPDATE_ALWAYS ) ;
return reflection_probe - > update_mode ;
2017-12-04 13:41:34 +01:00
}
uint32_t RasterizerStorageGLES2 : : reflection_probe_get_cull_mask ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , 0 ) ;
return reflection_probe - > cull_mask ;
2017-12-04 13:41:34 +01:00
}
Vector3 RasterizerStorageGLES2 : : reflection_probe_get_extents ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , Vector3 ( ) ) ;
return reflection_probe - > extents ;
2017-12-04 13:41:34 +01:00
}
Vector3 RasterizerStorageGLES2 : : reflection_probe_get_origin_offset ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , Vector3 ( ) ) ;
return reflection_probe - > origin_offset ;
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : reflection_probe_renders_shadows ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , false ) ;
return reflection_probe - > enable_shadows ;
2017-12-04 13:41:34 +01:00
}
float RasterizerStorageGLES2 : : reflection_probe_get_origin_max_distance ( RID p_probe ) const {
2018-09-28 21:40:20 +02:00
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , 0 ) ;
return reflection_probe - > max_distance ;
}
int RasterizerStorageGLES2 : : reflection_probe_get_resolution ( RID p_probe ) const {
const ReflectionProbe * reflection_probe = reflection_probe_owner . getornull ( p_probe ) ;
ERR_FAIL_COND_V ( ! reflection_probe , 0 ) ;
return reflection_probe - > resolution ;
2017-12-04 13:41:34 +01:00
}
RID RasterizerStorageGLES2 : : gi_probe_create ( ) {
return RID ( ) ;
}
void RasterizerStorageGLES2 : : gi_probe_set_bounds ( RID p_probe , const AABB & p_bounds ) {
}
AABB RasterizerStorageGLES2 : : gi_probe_get_bounds ( RID p_probe ) const {
return AABB ( ) ;
}
void RasterizerStorageGLES2 : : gi_probe_set_cell_size ( RID p_probe , float p_size ) {
}
float RasterizerStorageGLES2 : : gi_probe_get_cell_size ( RID p_probe ) const {
return 0.0 ;
}
void RasterizerStorageGLES2 : : gi_probe_set_to_cell_xform ( RID p_probe , const Transform & p_xform ) {
}
Transform RasterizerStorageGLES2 : : gi_probe_get_to_cell_xform ( RID p_probe ) const {
return Transform ( ) ;
}
void RasterizerStorageGLES2 : : gi_probe_set_dynamic_data ( RID p_probe , const PoolVector < int > & p_data ) {
}
PoolVector < int > RasterizerStorageGLES2 : : gi_probe_get_dynamic_data ( RID p_probe ) const {
return PoolVector < int > ( ) ;
}
void RasterizerStorageGLES2 : : gi_probe_set_dynamic_range ( RID p_probe , int p_range ) {
}
int RasterizerStorageGLES2 : : gi_probe_get_dynamic_range ( RID p_probe ) const {
return 0 ;
}
void RasterizerStorageGLES2 : : gi_probe_set_energy ( RID p_probe , float p_range ) {
}
void RasterizerStorageGLES2 : : gi_probe_set_bias ( RID p_probe , float p_range ) {
}
void RasterizerStorageGLES2 : : gi_probe_set_normal_bias ( RID p_probe , float p_range ) {
}
void RasterizerStorageGLES2 : : gi_probe_set_propagation ( RID p_probe , float p_range ) {
}
void RasterizerStorageGLES2 : : gi_probe_set_interior ( RID p_probe , bool p_enable ) {
}
bool RasterizerStorageGLES2 : : gi_probe_is_interior ( RID p_probe ) const {
return false ;
}
void RasterizerStorageGLES2 : : gi_probe_set_compress ( RID p_probe , bool p_enable ) {
}
bool RasterizerStorageGLES2 : : gi_probe_is_compressed ( RID p_probe ) const {
return false ;
}
float RasterizerStorageGLES2 : : gi_probe_get_energy ( RID p_probe ) const {
return 0 ;
}
float RasterizerStorageGLES2 : : gi_probe_get_bias ( RID p_probe ) const {
return 0 ;
}
float RasterizerStorageGLES2 : : gi_probe_get_normal_bias ( RID p_probe ) const {
return 0 ;
}
float RasterizerStorageGLES2 : : gi_probe_get_propagation ( RID p_probe ) const {
return 0 ;
}
uint32_t RasterizerStorageGLES2 : : gi_probe_get_version ( RID p_probe ) {
return 0 ;
}
RasterizerStorage : : GIProbeCompression RasterizerStorageGLES2 : : gi_probe_get_dynamic_data_get_preferred_compression ( ) const {
return GI_PROBE_UNCOMPRESSED ;
}
RID RasterizerStorageGLES2 : : gi_probe_dynamic_data_create ( int p_width , int p_height , int p_depth , GIProbeCompression p_compression ) {
return RID ( ) ;
}
void RasterizerStorageGLES2 : : gi_probe_dynamic_data_update ( RID p_gi_probe_data , int p_depth_slice , int p_slice_count , int p_mipmap , const void * p_data ) {
}
///////
RID RasterizerStorageGLES2 : : lightmap_capture_create ( ) {
2018-09-29 01:32:40 +02:00
LightmapCapture * capture = memnew ( LightmapCapture ) ;
return lightmap_capture_data_owner . make_rid ( capture ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : lightmap_capture_set_bounds ( RID p_capture , const AABB & p_bounds ) {
2018-09-29 01:32:40 +02:00
LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND ( ! capture ) ;
capture - > bounds = p_bounds ;
2018-11-14 13:32:39 +01:00
capture - > instance_change_notify ( true , false ) ;
2017-12-04 13:41:34 +01:00
}
2018-09-29 01:32:40 +02:00
AABB RasterizerStorageGLES2 : : lightmap_capture_get_bounds ( RID p_capture ) const {
2017-12-04 13:41:34 +01:00
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , AABB ( ) ) ;
return capture - > bounds ;
2017-12-04 13:41:34 +01:00
}
2018-09-29 01:32:40 +02:00
void RasterizerStorageGLES2 : : lightmap_capture_set_octree ( RID p_capture , const PoolVector < uint8_t > & p_octree ) {
LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND ( ! capture ) ;
ERR_FAIL_COND ( p_octree . size ( ) = = 0 | | ( p_octree . size ( ) % sizeof ( LightmapCaptureOctree ) ) ! = 0 ) ;
2017-12-04 13:41:34 +01:00
2018-09-29 01:32:40 +02:00
capture - > octree . resize ( p_octree . size ( ) / sizeof ( LightmapCaptureOctree ) ) ;
if ( p_octree . size ( ) ) {
PoolVector < LightmapCaptureOctree > : : Write w = capture - > octree . write ( ) ;
PoolVector < uint8_t > : : Read r = p_octree . read ( ) ;
copymem ( w . ptr ( ) , r . ptr ( ) , p_octree . size ( ) ) ;
}
2018-11-14 13:32:39 +01:00
capture - > instance_change_notify ( true , false ) ;
2018-09-29 01:32:40 +02:00
}
2017-12-04 13:41:34 +01:00
PoolVector < uint8_t > RasterizerStorageGLES2 : : lightmap_capture_get_octree ( RID p_capture ) const {
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , PoolVector < uint8_t > ( ) ) ;
if ( capture - > octree . size ( ) = = 0 )
return PoolVector < uint8_t > ( ) ;
PoolVector < uint8_t > ret ;
ret . resize ( capture - > octree . size ( ) * sizeof ( LightmapCaptureOctree ) ) ;
{
PoolVector < LightmapCaptureOctree > : : Read r = capture - > octree . read ( ) ;
PoolVector < uint8_t > : : Write w = ret . write ( ) ;
copymem ( w . ptr ( ) , r . ptr ( ) , ret . size ( ) ) ;
}
return ret ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : lightmap_capture_set_octree_cell_transform ( RID p_capture , const Transform & p_xform ) {
2018-09-29 01:32:40 +02:00
LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND ( ! capture ) ;
capture - > cell_xform = p_xform ;
2017-12-04 13:41:34 +01:00
}
Transform RasterizerStorageGLES2 : : lightmap_capture_get_octree_cell_transform ( RID p_capture ) const {
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , Transform ( ) ) ;
return capture - > cell_xform ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : lightmap_capture_set_octree_cell_subdiv ( RID p_capture , int p_subdiv ) {
2018-09-29 01:32:40 +02:00
LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND ( ! capture ) ;
capture - > cell_subdiv = p_subdiv ;
2017-12-04 13:41:34 +01:00
}
int RasterizerStorageGLES2 : : lightmap_capture_get_octree_cell_subdiv ( RID p_capture ) const {
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , 0 ) ;
return capture - > cell_subdiv ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : lightmap_capture_set_energy ( RID p_capture , float p_energy ) {
2018-09-29 01:32:40 +02:00
LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND ( ! capture ) ;
capture - > energy = p_energy ;
2017-12-04 13:41:34 +01:00
}
float RasterizerStorageGLES2 : : lightmap_capture_get_energy ( RID p_capture ) const {
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , 0 ) ;
return capture - > energy ;
2017-12-04 13:41:34 +01:00
}
const PoolVector < RasterizerStorage : : LightmapCaptureOctree > * RasterizerStorageGLES2 : : lightmap_capture_get_octree_ptr ( RID p_capture ) const {
2018-09-29 01:32:40 +02:00
const LightmapCapture * capture = lightmap_capture_data_owner . getornull ( p_capture ) ;
ERR_FAIL_COND_V ( ! capture , NULL ) ;
return & capture - > octree ;
2017-12-04 13:41:34 +01:00
}
///////
RID RasterizerStorageGLES2 : : particles_create ( ) {
return RID ( ) ;
}
void RasterizerStorageGLES2 : : particles_set_emitting ( RID p_particles , bool p_emitting ) {
}
bool RasterizerStorageGLES2 : : particles_get_emitting ( RID p_particles ) {
return false ;
}
void RasterizerStorageGLES2 : : particles_set_amount ( RID p_particles , int p_amount ) {
}
void RasterizerStorageGLES2 : : particles_set_lifetime ( RID p_particles , float p_lifetime ) {
}
void RasterizerStorageGLES2 : : particles_set_one_shot ( RID p_particles , bool p_one_shot ) {
}
void RasterizerStorageGLES2 : : particles_set_pre_process_time ( RID p_particles , float p_time ) {
}
void RasterizerStorageGLES2 : : particles_set_explosiveness_ratio ( RID p_particles , float p_ratio ) {
}
void RasterizerStorageGLES2 : : particles_set_randomness_ratio ( RID p_particles , float p_ratio ) {
}
void RasterizerStorageGLES2 : : particles_set_custom_aabb ( RID p_particles , const AABB & p_aabb ) {
}
void RasterizerStorageGLES2 : : particles_set_speed_scale ( RID p_particles , float p_scale ) {
}
void RasterizerStorageGLES2 : : particles_set_use_local_coordinates ( RID p_particles , bool p_enable ) {
}
void RasterizerStorageGLES2 : : particles_set_fixed_fps ( RID p_particles , int p_fps ) {
}
void RasterizerStorageGLES2 : : particles_set_fractional_delta ( RID p_particles , bool p_enable ) {
}
void RasterizerStorageGLES2 : : particles_set_process_material ( RID p_particles , RID p_material ) {
}
void RasterizerStorageGLES2 : : particles_set_draw_order ( RID p_particles , VS : : ParticlesDrawOrder p_order ) {
}
void RasterizerStorageGLES2 : : particles_set_draw_passes ( RID p_particles , int p_passes ) {
}
void RasterizerStorageGLES2 : : particles_set_draw_pass_mesh ( RID p_particles , int p_pass , RID p_mesh ) {
}
void RasterizerStorageGLES2 : : particles_restart ( RID p_particles ) {
}
void RasterizerStorageGLES2 : : particles_request_process ( RID p_particles ) {
}
AABB RasterizerStorageGLES2 : : particles_get_current_aabb ( RID p_particles ) {
return AABB ( ) ;
}
AABB RasterizerStorageGLES2 : : particles_get_aabb ( RID p_particles ) const {
return AABB ( ) ;
}
void RasterizerStorageGLES2 : : particles_set_emission_transform ( RID p_particles , const Transform & p_transform ) {
}
int RasterizerStorageGLES2 : : particles_get_draw_passes ( RID p_particles ) const {
return 0 ;
}
RID RasterizerStorageGLES2 : : particles_get_draw_pass_mesh ( RID p_particles , int p_pass ) const {
return RID ( ) ;
}
void RasterizerStorageGLES2 : : update_particles ( ) {
}
2018-11-20 00:34:29 +01:00
bool RasterizerStorageGLES2 : : particles_is_inactive ( RID p_particles ) const {
return true ;
}
2017-12-04 13:41:34 +01:00
////////
void RasterizerStorageGLES2 : : instance_add_skeleton ( RID p_skeleton , RasterizerScene : : InstanceBase * p_instance ) {
2018-09-28 21:40:20 +02:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
skeleton - > instances . insert ( p_instance ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : instance_remove_skeleton ( RID p_skeleton , RasterizerScene : : InstanceBase * p_instance ) {
2018-09-28 21:40:20 +02:00
Skeleton * skeleton = skeleton_owner . getornull ( p_skeleton ) ;
ERR_FAIL_COND ( ! skeleton ) ;
skeleton - > instances . erase ( p_instance ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : instance_add_dependency ( RID p_base , RasterizerScene : : InstanceBase * p_instance ) {
2018-09-28 21:40:20 +02:00
2018-09-29 18:49:34 +02:00
Instantiable * inst = NULL ;
2018-09-28 21:40:20 +02:00
switch ( p_instance - > base_type ) {
case VS : : INSTANCE_MESH : {
inst = mesh_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_MULTIMESH : {
inst = multimesh_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_IMMEDIATE : {
inst = immediate_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
/*case VS::INSTANCE_PARTICLES: {
inst = particles_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ; */
case VS : : INSTANCE_REFLECTION_PROBE : {
inst = reflection_probe_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_LIGHT : {
inst = light_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
/*case VS::INSTANCE_GI_PROBE: {
inst = gi_probe_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ; */
2018-09-29 01:32:40 +02:00
case VS : : INSTANCE_LIGHTMAP_CAPTURE : {
2018-09-28 21:40:20 +02:00
inst = lightmap_capture_data_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
2018-09-29 01:32:40 +02:00
} break ;
2018-09-28 21:40:20 +02:00
default : {
2019-06-20 16:59:48 +02:00
ERR_FAIL ( ) ;
2018-09-28 21:40:20 +02:00
}
}
inst - > instance_list . add ( & p_instance - > dependency_item ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : instance_remove_dependency ( RID p_base , RasterizerScene : : InstanceBase * p_instance ) {
2018-09-28 21:40:20 +02:00
2018-09-29 18:49:34 +02:00
Instantiable * inst = NULL ;
2018-09-28 21:40:20 +02:00
switch ( p_instance - > base_type ) {
case VS : : INSTANCE_MESH : {
inst = mesh_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_MULTIMESH : {
inst = multimesh_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_IMMEDIATE : {
inst = immediate_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
/*case VS::INSTANCE_PARTICLES: {
inst = particles_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ; */
case VS : : INSTANCE_REFLECTION_PROBE : {
inst = reflection_probe_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
case VS : : INSTANCE_LIGHT : {
inst = light_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
} break ;
/*case VS::INSTANCE_GI_PROBE: {
inst = gi_probe_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
2018-09-29 01:32:40 +02:00
} break ; */
2018-09-28 21:40:20 +02:00
case VS : : INSTANCE_LIGHTMAP_CAPTURE : {
inst = lightmap_capture_data_owner . getornull ( p_base ) ;
ERR_FAIL_COND ( ! inst ) ;
2018-09-29 01:32:40 +02:00
} break ;
2018-09-28 21:40:20 +02:00
default : {
2019-06-20 16:59:48 +02:00
ERR_FAIL ( ) ;
2018-09-28 21:40:20 +02:00
}
}
inst - > instance_list . remove ( & p_instance - > dependency_item ) ;
2017-12-04 13:41:34 +01:00
}
/* RENDER TARGET */
void RasterizerStorageGLES2 : : _render_target_allocate ( RenderTarget * rt ) {
2019-05-08 20:25:34 +02:00
// do not allocate a render target with no size
2017-12-04 13:41:34 +01:00
if ( rt - > width < = 0 | | rt - > height < = 0 )
return ;
2019-05-08 20:25:34 +02:00
// do not allocate a render target that is attached to the screen
if ( rt - > flags [ RENDER_TARGET_DIRECT_TO_SCREEN ] ) {
rt - > fbo = RasterizerStorageGLES2 : : system_fbo ;
return ;
}
2019-04-29 20:51:09 +02:00
GLuint color_internal_format ;
GLuint color_format ;
GLuint color_type = GL_UNSIGNED_BYTE ;
2019-11-18 22:25:03 +01:00
Image : : Format image_format ;
2019-02-22 15:32:37 +01:00
if ( rt - > flags [ RasterizerStorage : : RENDER_TARGET_TRANSPARENT ] ) {
2019-11-18 22:25:03 +01:00
# ifdef GLES_OVER_GL
color_internal_format = GL_RGBA8 ;
# else
2019-04-29 20:51:09 +02:00
color_internal_format = GL_RGBA ;
2019-11-18 22:25:03 +01:00
# endif
2019-04-29 20:51:09 +02:00
color_format = GL_RGBA ;
2019-11-18 22:25:03 +01:00
image_format = Image : : FORMAT_RGBA8 ;
2019-02-22 15:32:37 +01:00
} else {
2019-11-18 22:25:03 +01:00
# ifdef GLES_OVER_GL
color_internal_format = GL_RGB8 ;
# else
2019-04-29 20:51:09 +02:00
color_internal_format = GL_RGB ;
2019-11-18 22:25:03 +01:00
# endif
2019-04-29 20:51:09 +02:00
color_format = GL_RGB ;
2019-11-18 22:25:03 +01:00
image_format = Image : : FORMAT_RGB8 ;
2019-02-22 15:32:37 +01:00
}
2017-12-04 13:41:34 +01:00
2019-09-01 00:03:55 +02:00
rt - > used_dof_blur_near = false ;
rt - > mip_maps_allocated = false ;
2019-04-29 20:51:09 +02:00
{
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
/* Front FBO */
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
Texture * texture = texture_owner . getornull ( rt - > texture ) ;
ERR_FAIL_COND ( ! texture ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
// framebuffer
glGenFramebuffers ( 1 , & rt - > fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , rt - > fbo ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
// color
glGenTextures ( 1 , & rt - > color ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > color ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
glTexImage2D ( GL_TEXTURE_2D , 0 , color_internal_format , rt - > width , rt - > height , 0 , color_format , color_type , NULL ) ;
2019-02-22 15:32:37 +01:00
2019-04-29 20:51:09 +02:00
if ( texture - > flags & VS : : TEXTURE_FLAG_FILTER ) {
2019-02-26 23:45:15 +01:00
2019-04-29 20:51:09 +02:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
} else {
2019-02-22 15:32:37 +01:00
2019-04-29 20:51:09 +02:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
}
2019-03-01 15:20:44 +01:00
2019-04-29 20:51:09 +02:00
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , rt - > color , 0 ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
// depth
2017-12-04 13:41:34 +01:00
2019-03-01 15:20:44 +01:00
if ( config . support_depth_texture ) {
2019-04-29 20:51:09 +02:00
glGenTextures ( 1 , & rt - > depth ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > depth ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , config . depth_internalformat , rt - > width , rt - > height , 0 , GL_DEPTH_COMPONENT , config . depth_type , NULL ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_TEXTURE_2D , rt - > depth , 0 ) ;
2019-03-01 15:20:44 +01:00
} else {
2019-04-29 20:51:09 +02:00
glGenRenderbuffers ( 1 , & rt - > depth ) ;
glBindRenderbuffer ( GL_RENDERBUFFER , rt - > depth ) ;
2019-11-24 03:08:19 +01:00
glRenderbufferStorage ( GL_RENDERBUFFER , config . depth_buffer_internalformat , rt - > width , rt - > height ) ;
2019-04-29 20:51:09 +02:00
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , rt - > depth ) ;
2019-03-01 15:20:44 +01:00
}
2019-04-29 20:51:09 +02:00
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
glDeleteFramebuffers ( 1 , & rt - > fbo ) ;
if ( config . support_depth_texture ) {
glDeleteTextures ( 1 , & rt - > depth ) ;
} else {
glDeleteRenderbuffers ( 1 , & rt - > depth ) ;
}
glDeleteTextures ( 1 , & rt - > color ) ;
rt - > fbo = 0 ;
rt - > width = 0 ;
rt - > height = 0 ;
rt - > color = 0 ;
rt - > depth = 0 ;
texture - > tex_id = 0 ;
texture - > active = false ;
WARN_PRINT ( " Could not create framebuffer!! " ) ;
return ;
}
2019-11-18 22:25:03 +01:00
texture - > format = image_format ;
texture - > gl_format_cache = color_format ;
2019-04-29 20:51:09 +02:00
texture - > gl_type_cache = GL_UNSIGNED_BYTE ;
2019-11-18 22:25:03 +01:00
texture - > gl_internal_format_cache = color_internal_format ;
2019-04-29 20:51:09 +02:00
texture - > tex_id = rt - > color ;
texture - > width = rt - > width ;
texture - > alloc_width = rt - > width ;
texture - > height = rt - > height ;
texture - > alloc_height = rt - > height ;
texture - > active = true ;
texture_set_flags ( rt - > texture , texture - > flags ) ;
2017-12-04 13:41:34 +01:00
}
2019-04-29 20:51:09 +02:00
/* BACK FBO */
/* For MSAA */
2019-06-14 17:50:41 +02:00
# ifndef JAVASCRIPT_ENABLED
2019-11-10 09:30:20 +01:00
if ( rt - > msaa > = VS : : VIEWPORT_MSAA_2X & & rt - > msaa < = VS : : VIEWPORT_MSAA_16X & & config . multisample_supported ) {
2019-04-29 20:51:09 +02:00
rt - > multisample_active = true ;
static const int msaa_value [ ] = { 0 , 2 , 4 , 8 , 16 } ;
int msaa = msaa_value [ rt - > msaa ] ;
int max_samples = 0 ;
glGetIntegerv ( GL_MAX_SAMPLES , & max_samples ) ;
if ( msaa > max_samples ) {
WARN_PRINTS ( " MSAA must be <= GL_MAX_SAMPLES, falling-back to GL_MAX_SAMPLES = " + itos ( max_samples ) ) ;
msaa = max_samples ;
}
//regular fbo
glGenFramebuffers ( 1 , & rt - > multisample_fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , rt - > multisample_fbo ) ;
glGenRenderbuffers ( 1 , & rt - > multisample_depth ) ;
glBindRenderbuffer ( GL_RENDERBUFFER , rt - > multisample_depth ) ;
2019-11-24 03:08:19 +01:00
glRenderbufferStorageMultisample ( GL_RENDERBUFFER , msaa , config . depth_buffer_internalformat , rt - > width , rt - > height ) ;
2019-04-29 20:51:09 +02:00
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , rt - > multisample_depth ) ;
# if defined(GLES_OVER_GL) || defined(IPHONE_ENABLED)
glGenRenderbuffers ( 1 , & rt - > multisample_color ) ;
glBindRenderbuffer ( GL_RENDERBUFFER , rt - > multisample_color ) ;
glRenderbufferStorageMultisample ( GL_RENDERBUFFER , msaa , color_internal_format , rt - > width , rt - > height ) ;
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_RENDERBUFFER , rt - > multisample_color ) ;
2019-06-05 08:12:20 +02:00
# elif ANDROID_ENABLED
2019-04-29 20:51:09 +02:00
// Render to a texture in android
glGenTextures ( 1 , & rt - > multisample_color ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > multisample_color ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , color_internal_format , rt - > width , rt - > height , 0 , color_format , color_type , NULL ) ;
// multisample buffer is same size as front buffer, so just use nearest
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
2019-10-28 00:50:15 +01:00
glFramebufferTexture2DMultisample ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , rt - > multisample_color , 0 , msaa ) ;
2019-04-29 20:51:09 +02:00
# endif
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
2019-10-30 15:45:09 +01:00
// Delete allocated resources and default to no MSAA
2019-10-28 00:50:15 +01:00
WARN_PRINT_ONCE ( " Cannot allocate back framebuffer for MSAA " ) ;
2019-04-29 20:51:09 +02:00
printf ( " err status: %x \n " , status ) ;
2019-10-30 15:45:09 +01:00
config . multisample_supported = false ;
rt - > multisample_active = false ;
glDeleteFramebuffers ( 1 , & rt - > multisample_fbo ) ;
rt - > multisample_fbo = 0 ;
glDeleteRenderbuffers ( 1 , & rt - > multisample_depth ) ;
rt - > multisample_depth = 0 ;
# ifdef ANDROID_ENABLED
glDeleteTextures ( 1 , & rt - > multisample_color ) ;
# else
glDeleteRenderbuffers ( 1 , & rt - > multisample_color ) ;
# endif
rt - > multisample_color = 0 ;
2019-04-29 20:51:09 +02:00
}
glBindRenderbuffer ( GL_RENDERBUFFER , 0 ) ;
2019-10-30 15:45:09 +01:00
glBindFramebuffer ( GL_FRAMEBUFFER , 0 ) ;
# ifdef ANDROID_ENABLED
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
# endif
2017-12-04 13:41:34 +01:00
2019-06-14 17:50:41 +02:00
} else
2019-10-30 15:45:09 +01:00
# endif // JAVASCRIPT_ENABLED
2019-06-14 17:50:41 +02:00
{
2019-04-29 20:51:09 +02:00
rt - > multisample_active = false ;
}
2017-12-04 13:41:34 +01:00
2018-08-15 17:12:21 +02:00
glClearColor ( 0 , 0 , 0 , 0 ) ;
2018-02-24 14:48:22 +01:00
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ;
2017-12-04 13:41:34 +01:00
// copy texscreen buffers
2019-01-24 21:00:33 +01:00
if ( ! ( rt - > flags [ RasterizerStorage : : RENDER_TARGET_NO_SAMPLING ] ) ) {
2017-12-04 13:41:34 +01:00
glGenTextures ( 1 , & rt - > copy_screen_effect . color ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > copy_screen_effect . color ) ;
2019-02-22 15:32:37 +01:00
if ( rt - > flags [ RasterizerStorage : : RENDER_TARGET_TRANSPARENT ] ) {
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , rt - > width , rt - > height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , NULL ) ;
} else {
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , rt - > width , rt - > height , 0 , GL_RGB , GL_UNSIGNED_BYTE , NULL ) ;
}
2019-01-24 21:00:33 +01:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
2017-12-04 13:41:34 +01:00
glGenFramebuffers ( 1 , & rt - > copy_screen_effect . fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , rt - > copy_screen_effect . fbo ) ;
2019-01-24 21:00:33 +01:00
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , rt - > copy_screen_effect . color , 0 ) ;
glClearColor ( 0 , 0 , 0 , 0 ) ;
glClear ( GL_COLOR_BUFFER_BIT ) ;
2017-12-04 13:41:34 +01:00
2019-04-29 20:51:09 +02:00
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
2017-12-04 13:41:34 +01:00
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
_render_target_clear ( rt ) ;
ERR_FAIL_COND ( status ! = GL_FRAMEBUFFER_COMPLETE ) ;
}
}
2019-09-01 00:03:55 +02:00
// Allocate mipmap chains for post_process effects
if ( ! rt - > flags [ RasterizerStorage : : RENDER_TARGET_NO_3D ] & & rt - > width > = 2 & & rt - > height > = 2 ) {
for ( int i = 0 ; i < 2 ; i + + ) {
ERR_FAIL_COND ( rt - > mip_maps [ i ] . sizes . size ( ) ) ;
int w = rt - > width ;
int h = rt - > height ;
if ( i > 0 ) {
w > > = 1 ;
h > > = 1 ;
}
int level = 0 ;
int fb_w = w ;
int fb_h = h ;
while ( true ) {
RenderTarget : : MipMaps : : Size mm ;
mm . width = w ;
mm . height = h ;
rt - > mip_maps [ i ] . sizes . push_back ( mm ) ;
w > > = 1 ;
h > > = 1 ;
if ( w < 2 | | h < 2 )
break ;
level + + ;
}
GLsizei width = fb_w ;
GLsizei height = fb_h ;
if ( config . render_to_mipmap_supported ) {
glGenTextures ( 1 , & rt - > mip_maps [ i ] . color ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > mip_maps [ i ] . color ) ;
for ( int l = 0 ; l < level + 1 ; l + + ) {
glTexImage2D ( GL_TEXTURE_2D , l , color_internal_format , width , height , 0 , color_format , color_type , NULL ) ;
width = MAX ( 1 , ( width / 2 ) ) ;
height = MAX ( 1 , ( height / 2 ) ) ;
}
# ifdef GLES_OVER_GL
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_BASE_LEVEL , 0 ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAX_LEVEL , level ) ;
# endif
} else {
// Can't render to specific levels of a mipmap in ES 2.0 or Webgl so create a texture for each level
for ( int l = 0 ; l < level + 1 ; l + + ) {
glGenTextures ( 1 , & rt - > mip_maps [ i ] . sizes . write [ l ] . color ) ;
glBindTexture ( GL_TEXTURE_2D , rt - > mip_maps [ i ] . sizes [ l ] . color ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , color_internal_format , width , height , 0 , color_format , color_type , NULL ) ;
width = MAX ( 1 , ( width / 2 ) ) ;
height = MAX ( 1 , ( height / 2 ) ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
}
}
glDisable ( GL_SCISSOR_TEST ) ;
glColorMask ( 1 , 1 , 1 , 1 ) ;
glDepthMask ( GL_TRUE ) ;
for ( int j = 0 ; j < rt - > mip_maps [ i ] . sizes . size ( ) ; j + + ) {
RenderTarget : : MipMaps : : Size & mm = rt - > mip_maps [ i ] . sizes . write [ j ] ;
glGenFramebuffers ( 1 , & mm . fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , mm . fbo ) ;
if ( config . render_to_mipmap_supported ) {
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , rt - > mip_maps [ i ] . color , j ) ;
} else {
glBindTexture ( GL_TEXTURE_2D , rt - > mip_maps [ i ] . sizes [ j ] . color ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , rt - > mip_maps [ i ] . sizes [ j ] . color , 0 ) ;
}
bool used_depth = false ;
if ( j = = 0 & & i = = 0 ) { //use always
2019-12-10 07:19:11 +01:00
if ( config . support_depth_texture ) {
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_TEXTURE_2D , rt - > depth , 0 ) ;
} else {
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , rt - > depth ) ;
}
2019-09-01 00:03:55 +02:00
used_depth = true ;
}
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
WARN_PRINT_ONCE ( " Cannot allocate mipmaps for 3D post processing effects " ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , RasterizerStorageGLES2 : : system_fbo ) ;
return ;
}
glClearColor ( 1.0 , 0.0 , 1.0 , 0.0 ) ;
glClear ( GL_COLOR_BUFFER_BIT ) ;
if ( used_depth ) {
glClearDepth ( 1.0 ) ;
glClear ( GL_DEPTH_BUFFER_BIT ) ;
}
}
rt - > mip_maps [ i ] . levels = level ;
if ( config . render_to_mipmap_supported ) {
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR_MIPMAP_LINEAR ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
}
}
rt - > mip_maps_allocated = true ;
}
2017-12-04 13:41:34 +01:00
glBindFramebuffer ( GL_FRAMEBUFFER , RasterizerStorageGLES2 : : system_fbo ) ;
}
void RasterizerStorageGLES2 : : _render_target_clear ( RenderTarget * rt ) {
2019-05-08 20:25:34 +02:00
// there is nothing to clear when DIRECT_TO_SCREEN is used
if ( rt - > flags [ RENDER_TARGET_DIRECT_TO_SCREEN ] )
return ;
2017-12-04 13:41:34 +01:00
if ( rt - > fbo ) {
glDeleteFramebuffers ( 1 , & rt - > fbo ) ;
glDeleteTextures ( 1 , & rt - > color ) ;
rt - > fbo = 0 ;
}
2019-03-30 14:03:49 +01:00
if ( rt - > external . fbo ! = 0 ) {
// free this
glDeleteFramebuffers ( 1 , & rt - > external . fbo ) ;
// clean up our texture
Texture * t = texture_owner . get ( rt - > external . texture ) ;
t - > alloc_height = 0 ;
t - > alloc_width = 0 ;
t - > width = 0 ;
t - > height = 0 ;
t - > active = false ;
texture_owner . free ( rt - > external . texture ) ;
memdelete ( t ) ;
rt - > external . fbo = 0 ;
}
2017-12-04 13:41:34 +01:00
if ( rt - > depth ) {
2019-03-01 15:20:44 +01:00
if ( config . support_depth_texture ) {
glDeleteTextures ( 1 , & rt - > depth ) ;
} else {
glDeleteRenderbuffers ( 1 , & rt - > depth ) ;
}
2017-12-04 13:41:34 +01:00
rt - > depth = 0 ;
}
Texture * tex = texture_owner . get ( rt - > texture ) ;
tex - > alloc_height = 0 ;
tex - > alloc_width = 0 ;
tex - > width = 0 ;
tex - > height = 0 ;
tex - > active = false ;
if ( rt - > copy_screen_effect . color ) {
glDeleteFramebuffers ( 1 , & rt - > copy_screen_effect . fbo ) ;
rt - > copy_screen_effect . fbo = 0 ;
glDeleteTextures ( 1 , & rt - > copy_screen_effect . color ) ;
rt - > copy_screen_effect . color = 0 ;
}
2019-04-29 20:51:09 +02:00
2019-09-01 00:03:55 +02:00
for ( int i = 0 ; i < 2 ; i + + ) {
if ( rt - > mip_maps [ i ] . sizes . size ( ) ) {
for ( int j = 0 ; j < rt - > mip_maps [ i ] . sizes . size ( ) ; j + + ) {
glDeleteFramebuffers ( 1 , & rt - > mip_maps [ i ] . sizes [ j ] . fbo ) ;
glDeleteTextures ( 1 , & rt - > mip_maps [ i ] . sizes [ j ] . color ) ;
}
glDeleteTextures ( 1 , & rt - > mip_maps [ i ] . color ) ;
rt - > mip_maps [ i ] . sizes . clear ( ) ;
rt - > mip_maps [ i ] . levels = 0 ;
rt - > mip_maps [ i ] . color = 0 ;
}
}
2019-04-29 20:51:09 +02:00
if ( rt - > multisample_active ) {
glDeleteFramebuffers ( 1 , & rt - > multisample_fbo ) ;
rt - > multisample_fbo = 0 ;
glDeleteRenderbuffers ( 1 , & rt - > multisample_depth ) ;
rt - > multisample_depth = 0 ;
2019-10-30 15:45:09 +01:00
# ifdef ANDROID_ENABLED
2019-04-29 20:51:09 +02:00
glDeleteTextures ( 1 , & rt - > multisample_color ) ;
2019-10-30 15:45:09 +01:00
# else
glDeleteRenderbuffers ( 1 , & rt - > multisample_color ) ;
2019-04-29 20:51:09 +02:00
# endif
rt - > multisample_color = 0 ;
}
2017-12-04 13:41:34 +01:00
}
RID RasterizerStorageGLES2 : : render_target_create ( ) {
RenderTarget * rt = memnew ( RenderTarget ) ;
Texture * t = memnew ( Texture ) ;
2018-12-29 13:16:04 +01:00
t - > type = VS : : TEXTURE_TYPE_2D ;
2017-12-04 13:41:34 +01:00
t - > flags = 0 ;
t - > width = 0 ;
t - > height = 0 ;
2018-08-27 02:22:56 +02:00
t - > alloc_height = 0 ;
2018-08-27 15:12:07 +02:00
t - > alloc_width = 0 ;
2017-12-04 13:41:34 +01:00
t - > format = Image : : FORMAT_R8 ;
t - > target = GL_TEXTURE_2D ;
t - > gl_format_cache = 0 ;
t - > gl_internal_format_cache = 0 ;
t - > gl_type_cache = 0 ;
t - > data_size = 0 ;
t - > total_data_size = 0 ;
t - > ignore_mipmaps = false ;
2018-02-24 14:48:22 +01:00
t - > compressed = false ;
2017-12-04 13:41:34 +01:00
t - > mipmaps = 1 ;
t - > active = true ;
t - > tex_id = 0 ;
t - > render_target = rt ;
rt - > texture = texture_owner . make_rid ( t ) ;
return render_target_owner . make_rid ( rt ) ;
}
2019-05-08 20:25:34 +02:00
void RasterizerStorageGLES2 : : render_target_set_position ( RID p_render_target , int p_x , int p_y ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
rt - > x = p_x ;
rt - > y = p_y ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : render_target_set_size ( RID p_render_target , int p_width , int p_height ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
if ( p_width = = rt - > width & & p_height = = rt - > height )
return ;
_render_target_clear ( rt ) ;
rt - > width = p_width ;
rt - > height = p_height ;
_render_target_allocate ( rt ) ;
}
RID RasterizerStorageGLES2 : : render_target_get_texture ( RID p_render_target ) const {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND_V ( ! rt , RID ( ) ) ;
2019-03-30 14:03:49 +01:00
if ( rt - > external . fbo = = 0 ) {
return rt - > texture ;
} else {
return rt - > external . texture ;
}
}
void RasterizerStorageGLES2 : : render_target_set_external_texture ( RID p_render_target , unsigned int p_texture_id ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
if ( p_texture_id = = 0 ) {
if ( rt - > external . fbo ! = 0 ) {
// free this
glDeleteFramebuffers ( 1 , & rt - > external . fbo ) ;
2019-11-10 09:30:20 +01:00
// and this
if ( rt - > external . depth ! = 0 ) {
glDeleteRenderbuffers ( 1 , & rt - > external . depth ) ;
}
2019-03-30 14:03:49 +01:00
// clean up our texture
Texture * t = texture_owner . get ( rt - > external . texture ) ;
t - > alloc_height = 0 ;
t - > alloc_width = 0 ;
t - > width = 0 ;
t - > height = 0 ;
t - > active = false ;
texture_owner . free ( rt - > external . texture ) ;
memdelete ( t ) ;
rt - > external . fbo = 0 ;
rt - > external . color = 0 ;
2019-11-10 09:30:20 +01:00
rt - > external . depth = 0 ;
2019-03-30 14:03:49 +01:00
}
} else {
Texture * t ;
if ( rt - > external . fbo = = 0 ) {
// create our fbo
glGenFramebuffers ( 1 , & rt - > external . fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , rt - > external . fbo ) ;
// allocate a texture
t = memnew ( Texture ) ;
t - > type = VS : : TEXTURE_TYPE_2D ;
t - > flags = 0 ;
t - > width = 0 ;
t - > height = 0 ;
t - > alloc_height = 0 ;
t - > alloc_width = 0 ;
t - > format = Image : : FORMAT_RGBA8 ;
t - > target = GL_TEXTURE_2D ;
t - > gl_format_cache = 0 ;
t - > gl_internal_format_cache = 0 ;
t - > gl_type_cache = 0 ;
t - > data_size = 0 ;
t - > compressed = false ;
t - > srgb = false ;
t - > total_data_size = 0 ;
t - > ignore_mipmaps = false ;
t - > mipmaps = 1 ;
t - > active = true ;
t - > tex_id = 0 ;
t - > render_target = rt ;
rt - > external . texture = texture_owner . make_rid ( t ) ;
2019-11-10 09:30:20 +01:00
2019-03-30 14:03:49 +01:00
} else {
// bind our frame buffer
glBindFramebuffer ( GL_FRAMEBUFFER , rt - > external . fbo ) ;
// find our texture
t = texture_owner . get ( rt - > external . texture ) ;
}
// set our texture
t - > tex_id = p_texture_id ;
rt - > external . color = p_texture_id ;
// size shouldn't be different
t - > width = rt - > width ;
t - > height = rt - > height ;
t - > alloc_height = rt - > width ;
t - > alloc_width = rt - > height ;
2019-11-10 09:30:20 +01:00
// Switch our texture on our frame buffer
# if ANDROID_ENABLED
if ( rt - > msaa > = VS : : VIEWPORT_MSAA_EXT_2X & & rt - > msaa < = VS : : VIEWPORT_MSAA_EXT_4X ) {
// This code only applies to the Oculus Go and Oculus Quest. Due to the the tiled nature
// of the GPU we can do a single render pass by rendering directly into our texture chains
// texture and apply MSAA as we render.
// On any other hardware these two modes are ignored and we do not have any MSAA,
// the normal MSAA modes need to be used to enable our two pass approach
static const int msaa_value [ ] = { 2 , 4 } ;
int msaa = msaa_value [ rt - > msaa - VS : : VIEWPORT_MSAA_EXT_2X ] ;
if ( rt - > external . depth = = 0 ) {
// create a multisample depth buffer, we're not reusing Godots because Godot's didn't get created..
glGenRenderbuffers ( 1 , & rt - > external . depth ) ;
glBindRenderbuffer ( GL_RENDERBUFFER , rt - > external . depth ) ;
2019-11-24 03:08:19 +01:00
glRenderbufferStorageMultisample ( GL_RENDERBUFFER , msaa , config . depth_buffer_internalformat , rt - > width , rt - > height ) ;
2019-11-10 09:30:20 +01:00
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , rt - > external . depth ) ;
}
2019-03-30 14:03:49 +01:00
2019-11-10 09:30:20 +01:00
// and set our external texture as the texture...
glFramebufferTexture2DMultisample ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , p_texture_id , 0 , msaa ) ;
2019-11-03 17:50:46 +01:00
2019-11-10 09:30:20 +01:00
} else
# endif
{
// set our texture as the destination for our framebuffer
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , p_texture_id , 0 ) ;
// seeing we're rendering into this directly, better also use our depth buffer, just use our existing one :)
if ( config . support_depth_texture ) {
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_TEXTURE_2D , rt - > depth , 0 ) ;
} else {
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , rt - > depth ) ;
}
2019-03-30 14:03:49 +01:00
}
// check status and unbind
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , RasterizerStorageGLES2 : : system_fbo ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
printf ( " framebuffer fail, status: %x \n " , status ) ;
}
ERR_FAIL_COND ( status ! = GL_FRAMEBUFFER_COMPLETE ) ;
}
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : render_target_set_flag ( RID p_render_target , RenderTargetFlags p_flag , bool p_value ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
2019-05-08 20:25:34 +02:00
// When setting DIRECT_TO_SCREEN, you need to clear before the value is set, but allocate after as
// those functions change how they operate depending on the value of DIRECT_TO_SCREEN
if ( p_flag = = RENDER_TARGET_DIRECT_TO_SCREEN & & p_value ! = rt - > flags [ RENDER_TARGET_DIRECT_TO_SCREEN ] ) {
_render_target_clear ( rt ) ;
rt - > flags [ p_flag ] = p_value ;
_render_target_allocate ( rt ) ;
}
2017-12-04 13:41:34 +01:00
rt - > flags [ p_flag ] = p_value ;
switch ( p_flag ) {
2019-03-09 19:56:51 +01:00
case RENDER_TARGET_TRANSPARENT :
2017-12-04 13:41:34 +01:00
case RENDER_TARGET_HDR :
case RENDER_TARGET_NO_3D :
case RENDER_TARGET_NO_SAMPLING :
case RENDER_TARGET_NO_3D_EFFECTS : {
//must reset for these formats
_render_target_clear ( rt ) ;
_render_target_allocate ( rt ) ;
} break ;
2019-04-08 11:53:57 +02:00
default : {
}
2017-12-04 13:41:34 +01:00
}
}
bool RasterizerStorageGLES2 : : render_target_was_used ( RID p_render_target ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND_V ( ! rt , false ) ;
return rt - > used_in_frame ;
}
void RasterizerStorageGLES2 : : render_target_clear_used ( RID p_render_target ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
rt - > used_in_frame = false ;
}
void RasterizerStorageGLES2 : : render_target_set_msaa ( RID p_render_target , VS : : ViewportMSAA p_msaa ) {
RenderTarget * rt = render_target_owner . getornull ( p_render_target ) ;
ERR_FAIL_COND ( ! rt ) ;
if ( rt - > msaa = = p_msaa )
return ;
2019-04-29 20:51:09 +02:00
if ( ! config . multisample_supported ) {
ERR_PRINT ( " MSAA not supported on this hardware. " ) ;
return ;
}
2017-12-04 13:41:34 +01:00
_render_target_clear ( rt ) ;
rt - > msaa = p_msaa ;
_render_target_allocate ( rt ) ;
}
/* CANVAS SHADOW */
RID RasterizerStorageGLES2 : : canvas_light_shadow_buffer_create ( int p_width ) {
2018-12-20 14:09:07 +01:00
CanvasLightShadow * cls = memnew ( CanvasLightShadow ) ;
2019-01-17 14:40:36 +01:00
2018-12-20 14:09:07 +01:00
if ( p_width > config . max_texture_size )
p_width = config . max_texture_size ;
cls - > size = p_width ;
cls - > height = 16 ;
glActiveTexture ( GL_TEXTURE0 ) ;
glGenFramebuffers ( 1 , & cls - > fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , cls - > fbo ) ;
2019-03-01 15:20:44 +01:00
glGenRenderbuffers ( 1 , & cls - > depth ) ;
glBindRenderbuffer ( GL_RENDERBUFFER , cls - > depth ) ;
2019-11-24 03:08:19 +01:00
glRenderbufferStorage ( GL_RENDERBUFFER , config . depth_buffer_internalformat , cls - > size , cls - > height ) ;
2019-03-01 15:20:44 +01:00
glFramebufferRenderbuffer ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_RENDERBUFFER , cls - > depth ) ;
2018-12-20 14:09:07 +01:00
glGenTextures ( 1 , & cls - > distance ) ;
glBindTexture ( GL_TEXTURE_2D , cls - > distance ) ;
if ( config . use_rgba_2d_shadows ) {
2018-12-21 13:50:15 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGBA , cls - > size , cls - > height , 0 , GL_RGBA , GL_UNSIGNED_BYTE , NULL ) ;
2018-12-20 14:09:07 +01:00
} else {
2018-12-21 13:50:15 +01:00
# ifdef GLES_OVER_GL
2018-12-21 14:01:16 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_R32F , cls - > size , cls - > height , 0 , _RED_OES , GL_FLOAT , NULL ) ;
2018-12-21 13:50:15 +01:00
# else
2018-12-21 14:01:16 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_FLOAT , cls - > size , cls - > height , 0 , _RED_OES , GL_FLOAT , NULL ) ;
2018-12-21 13:50:15 +01:00
# endif
2018-12-20 14:09:07 +01:00
}
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_COLOR_ATTACHMENT0 , GL_TEXTURE_2D , cls - > distance , 0 ) ;
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
//printf("errnum: %x\n",status);
glBindFramebuffer ( GL_FRAMEBUFFER , RasterizerStorageGLES2 : : system_fbo ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
memdelete ( cls ) ;
ERR_FAIL_COND_V ( status ! = GL_FRAMEBUFFER_COMPLETE , RID ( ) ) ;
}
return canvas_light_shadow_owner . make_rid ( cls ) ;
2017-12-04 13:41:34 +01:00
}
/* LIGHT SHADOW MAPPING */
RID RasterizerStorageGLES2 : : canvas_light_occluder_create ( ) {
2018-12-20 14:09:07 +01:00
CanvasOccluder * co = memnew ( CanvasOccluder ) ;
co - > index_id = 0 ;
co - > vertex_id = 0 ;
co - > len = 0 ;
return canvas_occluder_owner . make_rid ( co ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : canvas_light_occluder_set_polylines ( RID p_occluder , const PoolVector < Vector2 > & p_lines ) {
2018-12-20 14:09:07 +01:00
CanvasOccluder * co = canvas_occluder_owner . get ( p_occluder ) ;
ERR_FAIL_COND ( ! co ) ;
co - > lines = p_lines ;
if ( p_lines . size ( ) ! = co - > len ) {
if ( co - > index_id )
glDeleteBuffers ( 1 , & co - > index_id ) ;
if ( co - > vertex_id )
glDeleteBuffers ( 1 , & co - > vertex_id ) ;
co - > index_id = 0 ;
co - > vertex_id = 0 ;
co - > len = 0 ;
}
if ( p_lines . size ( ) ) {
PoolVector < float > geometry ;
PoolVector < uint16_t > indices ;
int lc = p_lines . size ( ) ;
geometry . resize ( lc * 6 ) ;
indices . resize ( lc * 3 ) ;
PoolVector < float > : : Write vw = geometry . write ( ) ;
PoolVector < uint16_t > : : Write iw = indices . write ( ) ;
PoolVector < Vector2 > : : Read lr = p_lines . read ( ) ;
const int POLY_HEIGHT = 16384 ;
for ( int i = 0 ; i < lc / 2 ; i + + ) {
vw [ i * 12 + 0 ] = lr [ i * 2 + 0 ] . x ;
vw [ i * 12 + 1 ] = lr [ i * 2 + 0 ] . y ;
vw [ i * 12 + 2 ] = POLY_HEIGHT ;
vw [ i * 12 + 3 ] = lr [ i * 2 + 1 ] . x ;
vw [ i * 12 + 4 ] = lr [ i * 2 + 1 ] . y ;
vw [ i * 12 + 5 ] = POLY_HEIGHT ;
vw [ i * 12 + 6 ] = lr [ i * 2 + 1 ] . x ;
vw [ i * 12 + 7 ] = lr [ i * 2 + 1 ] . y ;
vw [ i * 12 + 8 ] = - POLY_HEIGHT ;
vw [ i * 12 + 9 ] = lr [ i * 2 + 0 ] . x ;
vw [ i * 12 + 10 ] = lr [ i * 2 + 0 ] . y ;
vw [ i * 12 + 11 ] = - POLY_HEIGHT ;
iw [ i * 6 + 0 ] = i * 4 + 0 ;
iw [ i * 6 + 1 ] = i * 4 + 1 ;
iw [ i * 6 + 2 ] = i * 4 + 2 ;
iw [ i * 6 + 3 ] = i * 4 + 2 ;
iw [ i * 6 + 4 ] = i * 4 + 3 ;
iw [ i * 6 + 5 ] = i * 4 + 0 ;
}
//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
if ( ! co - > vertex_id ) {
glGenBuffers ( 1 , & co - > vertex_id ) ;
glBindBuffer ( GL_ARRAY_BUFFER , co - > vertex_id ) ;
glBufferData ( GL_ARRAY_BUFFER , lc * 6 * sizeof ( real_t ) , vw . ptr ( ) , GL_STATIC_DRAW ) ;
} else {
glBindBuffer ( GL_ARRAY_BUFFER , co - > vertex_id ) ;
glBufferSubData ( GL_ARRAY_BUFFER , 0 , lc * 6 * sizeof ( real_t ) , vw . ptr ( ) ) ;
}
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ; //unbind
if ( ! co - > index_id ) {
glGenBuffers ( 1 , & co - > index_id ) ;
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , co - > index_id ) ;
glBufferData ( GL_ELEMENT_ARRAY_BUFFER , lc * 3 * sizeof ( uint16_t ) , iw . ptr ( ) , GL_DYNAMIC_DRAW ) ;
} else {
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , co - > index_id ) ;
glBufferSubData ( GL_ELEMENT_ARRAY_BUFFER , 0 , lc * 3 * sizeof ( uint16_t ) , iw . ptr ( ) ) ;
}
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , 0 ) ; //unbind
co - > len = lc ;
}
2017-12-04 13:41:34 +01:00
}
VS : : InstanceType RasterizerStorageGLES2 : : get_base_type ( RID p_rid ) const {
2018-02-24 14:48:22 +01:00
if ( mesh_owner . owns ( p_rid ) ) {
return VS : : INSTANCE_MESH ;
2018-08-13 16:16:23 +02:00
} else if ( light_owner . owns ( p_rid ) ) {
2018-02-24 14:48:22 +01:00
return VS : : INSTANCE_LIGHT ;
2018-08-13 16:16:23 +02:00
} else if ( multimesh_owner . owns ( p_rid ) ) {
2018-02-24 14:48:22 +01:00
return VS : : INSTANCE_MULTIMESH ;
2018-08-13 16:16:23 +02:00
} else if ( immediate_owner . owns ( p_rid ) ) {
return VS : : INSTANCE_IMMEDIATE ;
2018-09-28 21:40:20 +02:00
} else if ( reflection_probe_owner . owns ( p_rid ) ) {
return VS : : INSTANCE_REFLECTION_PROBE ;
2018-09-29 01:32:40 +02:00
} else if ( lightmap_capture_data_owner . owns ( p_rid ) ) {
return VS : : INSTANCE_LIGHTMAP_CAPTURE ;
2018-08-13 16:16:23 +02:00
} else {
return VS : : INSTANCE_NONE ;
2018-02-24 14:48:22 +01:00
}
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : free ( RID p_rid ) {
2018-02-24 14:48:22 +01:00
if ( render_target_owner . owns ( p_rid ) ) {
RenderTarget * rt = render_target_owner . getornull ( p_rid ) ;
_render_target_clear ( rt ) ;
Texture * t = texture_owner . get ( rt - > texture ) ;
texture_owner . free ( rt - > texture ) ;
memdelete ( t ) ;
render_target_owner . free ( p_rid ) ;
memdelete ( rt ) ;
return true ;
} else if ( texture_owner . owns ( p_rid ) ) {
Texture * t = texture_owner . get ( p_rid ) ;
// can't free a render target texture
ERR_FAIL_COND_V ( t - > render_target , true ) ;
info . texture_mem - = t - > total_data_size ;
texture_owner . free ( p_rid ) ;
memdelete ( t ) ;
return true ;
} else if ( sky_owner . owns ( p_rid ) ) {
Sky * sky = sky_owner . get ( p_rid ) ;
sky_set_texture ( p_rid , RID ( ) , 256 ) ;
sky_owner . free ( p_rid ) ;
memdelete ( sky ) ;
return true ;
} else if ( shader_owner . owns ( p_rid ) ) {
Shader * shader = shader_owner . get ( p_rid ) ;
2019-01-26 14:39:03 +01:00
if ( shader - > shader & & shader - > custom_code_id ) {
2018-02-24 14:48:22 +01:00
shader - > shader - > free_custom_shader ( shader - > custom_code_id ) ;
}
if ( shader - > dirty_list . in_list ( ) ) {
_shader_dirty_list . remove ( & shader - > dirty_list ) ;
}
while ( shader - > materials . first ( ) ) {
Material * m = shader - > materials . first ( ) - > self ( ) ;
m - > shader = NULL ;
_material_make_dirty ( m ) ;
shader - > materials . remove ( shader - > materials . first ( ) ) ;
}
shader_owner . free ( p_rid ) ;
memdelete ( shader ) ;
return true ;
} else if ( material_owner . owns ( p_rid ) ) {
Material * m = material_owner . get ( p_rid ) ;
if ( m - > shader ) {
m - > shader - > materials . remove ( & m - > list ) ;
}
for ( Map < Geometry * , int > : : Element * E = m - > geometry_owners . front ( ) ; E ; E = E - > next ( ) ) {
Geometry * g = E - > key ( ) ;
g - > material = RID ( ) ;
}
for ( Map < RasterizerScene : : InstanceBase * , int > : : Element * E = m - > instance_owners . front ( ) ; E ; E = E - > next ( ) ) {
RasterizerScene : : InstanceBase * ins = E - > key ( ) ;
if ( ins - > material_override = = p_rid ) {
ins - > material_override = RID ( ) ;
}
for ( int i = 0 ; i < ins - > materials . size ( ) ; i + + ) {
if ( ins - > materials [ i ] = = p_rid ) {
ins - > materials . write [ i ] = RID ( ) ;
}
}
}
material_owner . free ( p_rid ) ;
memdelete ( m ) ;
return true ;
} else if ( skeleton_owner . owns ( p_rid ) ) {
Skeleton * s = skeleton_owner . get ( p_rid ) ;
if ( s - > update_list . in_list ( ) ) {
skeleton_update_list . remove ( & s - > update_list ) ;
}
for ( Set < RasterizerScene : : InstanceBase * > : : Element * E = s - > instances . front ( ) ; E ; E = E - > next ( ) ) {
E - > get ( ) - > skeleton = RID ( ) ;
}
skeleton_allocate ( p_rid , 0 , false ) ;
if ( s - > tex_id ) {
glDeleteTextures ( 1 , & s - > tex_id ) ;
}
skeleton_owner . free ( p_rid ) ;
memdelete ( s ) ;
return true ;
} else if ( mesh_owner . owns ( p_rid ) ) {
Mesh * mesh = mesh_owner . get ( p_rid ) ;
mesh - > instance_remove_deps ( ) ;
mesh_clear ( p_rid ) ;
while ( mesh - > multimeshes . first ( ) ) {
MultiMesh * multimesh = mesh - > multimeshes . first ( ) - > self ( ) ;
multimesh - > mesh = RID ( ) ;
multimesh - > dirty_aabb = true ;
mesh - > multimeshes . remove ( mesh - > multimeshes . first ( ) ) ;
if ( ! multimesh - > update_list . in_list ( ) ) {
multimesh_update_list . add ( & multimesh - > update_list ) ;
}
}
mesh_owner . free ( p_rid ) ;
memdelete ( mesh ) ;
return true ;
} else if ( multimesh_owner . owns ( p_rid ) ) {
MultiMesh * multimesh = multimesh_owner . get ( p_rid ) ;
multimesh - > instance_remove_deps ( ) ;
if ( multimesh - > mesh . is_valid ( ) ) {
Mesh * mesh = mesh_owner . getornull ( multimesh - > mesh ) ;
if ( mesh ) {
mesh - > multimeshes . remove ( & multimesh - > mesh_list ) ;
}
}
multimesh_allocate ( p_rid , 0 , VS : : MULTIMESH_TRANSFORM_3D , VS : : MULTIMESH_COLOR_NONE ) ;
update_dirty_multimeshes ( ) ;
multimesh_owner . free ( p_rid ) ;
memdelete ( multimesh ) ;
2018-08-13 16:16:23 +02:00
return true ;
} else if ( immediate_owner . owns ( p_rid ) ) {
Immediate * im = immediate_owner . get ( p_rid ) ;
im - > instance_remove_deps ( ) ;
immediate_owner . free ( p_rid ) ;
memdelete ( im ) ;
2018-02-24 14:48:22 +01:00
return true ;
} else if ( light_owner . owns ( p_rid ) ) {
Light * light = light_owner . get ( p_rid ) ;
light - > instance_remove_deps ( ) ;
light_owner . free ( p_rid ) ;
memdelete ( light ) ;
return true ;
2018-09-28 21:40:20 +02:00
} else if ( reflection_probe_owner . owns ( p_rid ) ) {
// delete the texture
ReflectionProbe * reflection_probe = reflection_probe_owner . get ( p_rid ) ;
reflection_probe - > instance_remove_deps ( ) ;
reflection_probe_owner . free ( p_rid ) ;
memdelete ( reflection_probe ) ;
return true ;
2018-09-29 01:32:40 +02:00
} else if ( lightmap_capture_data_owner . owns ( p_rid ) ) {
2018-09-28 21:40:20 +02:00
2018-09-29 01:32:40 +02:00
// delete the texture
LightmapCapture * lightmap_capture = lightmap_capture_data_owner . get ( p_rid ) ;
lightmap_capture - > instance_remove_deps ( ) ;
lightmap_capture_data_owner . free ( p_rid ) ;
memdelete ( lightmap_capture ) ;
return true ;
2018-12-20 14:09:07 +01:00
} else if ( canvas_occluder_owner . owns ( p_rid ) ) {
CanvasOccluder * co = canvas_occluder_owner . get ( p_rid ) ;
if ( co - > index_id )
glDeleteBuffers ( 1 , & co - > index_id ) ;
if ( co - > vertex_id )
glDeleteBuffers ( 1 , & co - > vertex_id ) ;
canvas_occluder_owner . free ( p_rid ) ;
memdelete ( co ) ;
return true ;
} else if ( canvas_light_shadow_owner . owns ( p_rid ) ) {
CanvasLightShadow * cls = canvas_light_shadow_owner . get ( p_rid ) ;
glDeleteFramebuffers ( 1 , & cls - > fbo ) ;
2019-03-01 15:20:44 +01:00
glDeleteRenderbuffers ( 1 , & cls - > depth ) ;
2018-12-20 14:09:07 +01:00
glDeleteTextures ( 1 , & cls - > distance ) ;
canvas_light_shadow_owner . free ( p_rid ) ;
memdelete ( cls ) ;
return true ;
2018-02-24 14:48:22 +01:00
} else {
return false ;
}
2017-12-04 13:41:34 +01:00
}
bool RasterizerStorageGLES2 : : has_os_feature ( const String & p_feature ) const {
2018-02-24 14:48:22 +01:00
2019-02-26 15:58:47 +01:00
if ( p_feature = = " pvrtc " )
return config . pvrtc_supported ;
2018-02-24 14:48:22 +01:00
if ( p_feature = = " s3tc " )
return config . s3tc_supported ;
if ( p_feature = = " etc " )
return config . etc1_supported ;
2017-12-04 13:41:34 +01:00
return false ;
}
////////////////////////////////////////////
void RasterizerStorageGLES2 : : set_debug_generate_wireframes ( bool p_generate ) {
}
void RasterizerStorageGLES2 : : render_info_begin_capture ( ) {
2019-03-25 18:38:23 +01:00
info . snap = info . render ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : render_info_end_capture ( ) {
2019-03-25 18:38:23 +01:00
info . snap . object_count = info . render . object_count - info . snap . object_count ;
info . snap . draw_call_count = info . render . draw_call_count - info . snap . draw_call_count ;
info . snap . material_switch_count = info . render . material_switch_count - info . snap . material_switch_count ;
info . snap . surface_switch_count = info . render . surface_switch_count - info . snap . surface_switch_count ;
info . snap . shader_rebind_count = info . render . shader_rebind_count - info . snap . shader_rebind_count ;
info . snap . vertices_count = info . render . vertices_count - info . snap . vertices_count ;
2017-12-04 13:41:34 +01:00
}
int RasterizerStorageGLES2 : : get_captured_render_info ( VS : : RenderInfo p_info ) {
2019-03-25 18:38:23 +01:00
switch ( p_info ) {
case VS : : INFO_OBJECTS_IN_FRAME : {
return info . snap . object_count ;
} break ;
case VS : : INFO_VERTICES_IN_FRAME : {
return info . snap . vertices_count ;
} break ;
case VS : : INFO_MATERIAL_CHANGES_IN_FRAME : {
return info . snap . material_switch_count ;
} break ;
case VS : : INFO_SHADER_CHANGES_IN_FRAME : {
return info . snap . shader_rebind_count ;
} break ;
case VS : : INFO_SURFACE_CHANGES_IN_FRAME : {
return info . snap . surface_switch_count ;
} break ;
case VS : : INFO_DRAW_CALLS_IN_FRAME : {
return info . snap . draw_call_count ;
} break ;
default : {
return get_render_info ( p_info ) ;
}
}
2017-12-04 13:41:34 +01:00
}
int RasterizerStorageGLES2 : : get_render_info ( VS : : RenderInfo p_info ) {
2019-03-25 18:38:23 +01:00
switch ( p_info ) {
case VS : : INFO_OBJECTS_IN_FRAME :
return info . render_final . object_count ;
case VS : : INFO_VERTICES_IN_FRAME :
return info . render_final . vertices_count ;
case VS : : INFO_MATERIAL_CHANGES_IN_FRAME :
return info . render_final . material_switch_count ;
case VS : : INFO_SHADER_CHANGES_IN_FRAME :
return info . render_final . shader_rebind_count ;
case VS : : INFO_SURFACE_CHANGES_IN_FRAME :
return info . render_final . surface_switch_count ;
case VS : : INFO_DRAW_CALLS_IN_FRAME :
return info . render_final . draw_call_count ;
case VS : : INFO_USAGE_VIDEO_MEM_TOTAL :
return 0 ; //no idea
case VS : : INFO_VIDEO_MEM_USED :
return info . vertex_mem + info . texture_mem ;
case VS : : INFO_TEXTURE_MEM_USED :
return info . texture_mem ;
case VS : : INFO_VERTEX_MEM_USED :
return info . vertex_mem ;
default :
return 0 ; //no idea either
}
2017-12-04 13:41:34 +01:00
}
2019-09-13 20:08:05 +02:00
String RasterizerStorageGLES2 : : get_video_adapter_name ( ) const {
return ( const char * ) glGetString ( GL_RENDERER ) ;
}
String RasterizerStorageGLES2 : : get_video_adapter_vendor ( ) const {
return ( const char * ) glGetString ( GL_VENDOR ) ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : initialize ( ) {
RasterizerStorageGLES2 : : system_fbo = 0 ;
{
2018-02-24 14:48:22 +01:00
const GLubyte * extension_string = glGetString ( GL_EXTENSIONS ) ;
Vector < String > extensions = String ( ( const char * ) extension_string ) . split ( " " ) ;
for ( int i = 0 ; i < extensions . size ( ) ; i + + ) {
config . extensions . insert ( extensions [ i ] ) ;
2017-12-04 13:41:34 +01:00
}
}
2018-10-24 15:22:50 +02:00
config . keep_original_textures = false ;
2018-07-22 15:09:00 +02:00
config . shrink_textures_x2 = false ;
2019-11-24 03:08:19 +01:00
config . depth_internalformat = GL_DEPTH_COMPONENT ;
config . depth_type = GL_UNSIGNED_INT ;
2018-09-28 21:40:20 +02:00
2018-12-28 00:39:00 +01:00
# ifdef GLES_OVER_GL
config . float_texture_supported = true ;
config . s3tc_supported = true ;
2019-02-26 15:58:47 +01:00
config . pvrtc_supported = false ;
2018-12-28 00:39:00 +01:00
config . etc1_supported = false ;
2019-02-25 02:34:12 +01:00
config . support_npot_repeat_mipmap = true ;
2019-11-24 03:08:19 +01:00
config . depth_buffer_internalformat = GL_DEPTH_COMPONENT24 ;
2018-12-28 00:39:00 +01:00
# else
2018-09-27 13:11:41 +02:00
config . float_texture_supported = config . extensions . has ( " GL_ARB_texture_float " ) | | config . extensions . has ( " GL_OES_texture_float " ) ;
2019-01-26 22:25:03 +01:00
config . s3tc_supported = config . extensions . has ( " GL_EXT_texture_compression_s3tc " ) | | config . extensions . has ( " WEBGL_compressed_texture_s3tc " ) ;
config . etc1_supported = config . extensions . has ( " GL_OES_compressed_ETC1_RGB8_texture " ) | | config . extensions . has ( " WEBGL_compressed_texture_etc1 " ) ;
2019-10-27 00:28:54 +02:00
config . pvrtc_supported = config . extensions . has ( " IMG_texture_compression_pvrtc " ) | | config . extensions . has ( " WEBGL_compressed_texture_pvrtc " ) ;
2019-02-25 02:34:12 +01:00
config . support_npot_repeat_mipmap = config . extensions . has ( " GL_OES_texture_npot " ) ;
2019-11-24 03:08:19 +01:00
2019-12-10 07:14:12 +01:00
# ifdef JAVASCRIPT_ENABLED
2019-12-20 05:41:32 +01:00
// RenderBuffer internal format must be 16 bits in WebGL,
// but depth_texture should default to 32 always
2019-12-10 07:14:12 +01:00
// if the implementation doesn't support 32, it should just quietly use 16 instead
// https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/
2019-12-20 05:41:32 +01:00
config . depth_buffer_internalformat = GL_DEPTH_COMPONENT16 ;
2019-12-10 07:14:12 +01:00
config . depth_type = GL_UNSIGNED_INT ;
# else
2019-11-24 03:08:19 +01:00
// on mobile check for 24 bit depth support for RenderBufferStorage
2019-11-03 05:58:30 +01:00
if ( config . extensions . has ( " GL_OES_depth24 " ) ) {
2019-11-24 03:08:19 +01:00
config . depth_buffer_internalformat = _DEPTH_COMPONENT24_OES ;
2019-11-03 05:58:30 +01:00
config . depth_type = GL_UNSIGNED_INT ;
} else {
2019-11-24 03:08:19 +01:00
config . depth_buffer_internalformat = GL_DEPTH_COMPONENT16 ;
2019-11-03 05:58:30 +01:00
config . depth_type = GL_UNSIGNED_SHORT ;
}
2018-12-28 00:39:00 +01:00
# endif
2019-12-10 07:14:12 +01:00
# endif
2019-04-29 20:51:09 +02:00
# ifndef GLES_OVER_GL
//Manually load extensions for android and ios
# ifdef IPHONE_ENABLED
2019-06-05 08:12:20 +02:00
// appears that IPhone doesn't need to dlopen TODO: test this rigorously before removing
2019-04-29 20:51:09 +02:00
//void *gles2_lib = dlopen(NULL, RTLD_LAZY);
//glRenderbufferStorageMultisampleAPPLE = dlsym(gles2_lib, "glRenderbufferStorageMultisampleAPPLE");
//glResolveMultisampleFramebufferAPPLE = dlsym(gles2_lib, "glResolveMultisampleFramebufferAPPLE");
2019-06-05 08:12:20 +02:00
# elif ANDROID_ENABLED
2019-04-29 20:51:09 +02:00
void * gles2_lib = dlopen ( " libGLESv2.so " , RTLD_LAZY ) ;
glRenderbufferStorageMultisampleEXT = ( PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC ) dlsym ( gles2_lib , " glRenderbufferStorageMultisampleEXT " ) ;
glFramebufferTexture2DMultisampleEXT = ( PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC ) dlsym ( gles2_lib , " glFramebufferTexture2DMultisampleEXT " ) ;
# endif
# endif
// Check for multisample support
config . multisample_supported = config . extensions . has ( " GL_EXT_framebuffer_multisample " ) | | config . extensions . has ( " GL_EXT_multisampled_render_to_texture " ) | | config . extensions . has ( " GL_APPLE_framebuffer_multisample " ) ;
2019-09-01 00:03:55 +02:00
# ifdef GLES_OVER_GL
2019-10-06 21:07:31 +02:00
//TODO: causes huge problems with desktop video drivers. Making false for now, needs to be true to render SCREEN_TEXTURE mipmaps
config . render_to_mipmap_supported = false ;
2019-09-01 00:03:55 +02:00
# else
//check if mipmaps can be used for SCREEN_TEXTURE and Glow on Mobile and web platforms
config . render_to_mipmap_supported = config . extensions . has ( " GL_OES_fbo_render_mipmap " ) & & config . extensions . has ( " GL_EXT_texture_lod " ) ;
# endif
2018-12-21 13:50:15 +01:00
# ifdef GLES_OVER_GL
config . use_rgba_2d_shadows = false ;
2019-03-01 15:20:44 +01:00
config . support_depth_texture = true ;
2019-02-26 01:46:24 +01:00
config . use_rgba_3d_shadows = false ;
2019-03-01 15:20:44 +01:00
config . support_depth_cubemaps = true ;
2018-12-21 13:50:15 +01:00
# else
2018-12-21 14:02:43 +01:00
config . use_rgba_2d_shadows = ! ( config . float_texture_supported & & config . extensions . has ( " GL_EXT_texture_rg " ) ) ;
2019-10-26 19:17:22 +02:00
config . support_depth_texture = config . extensions . has ( " GL_OES_depth_texture " ) | | config . extensions . has ( " WEBGL_depth_texture " ) ;
2019-03-01 15:20:44 +01:00
config . use_rgba_3d_shadows = ! config . support_depth_texture ;
config . support_depth_cubemaps = config . extensions . has ( " GL_OES_depth_texture_cube_map " ) ;
2018-12-21 13:50:15 +01:00
# endif
2019-01-18 21:30:12 +01:00
# ifdef GLES_OVER_GL
config . support_32_bits_indices = true ;
# else
config . support_32_bits_indices = config . extensions . has ( " GL_OES_element_index_uint " ) ;
# endif
2019-01-22 14:04:25 +01:00
# ifdef GLES_OVER_GL
config . support_write_depth = true ;
2019-02-26 01:46:24 +01:00
# elif defined(JAVASCRIPT_ENABLED)
config . support_write_depth = false ;
2019-01-22 14:04:25 +01:00
# else
config . support_write_depth = config . extensions . has ( " GL_EXT_frag_depth " ) ;
# endif
2019-01-23 01:56:24 +01:00
# ifdef JAVASCRIPT_ENABLED
config . support_half_float_vertices = false ;
# else
//every other platform, be it mobile or desktop, supports this (even if not in the GLES2 spec).
config . support_half_float_vertices = true ;
# endif
2019-01-22 14:04:25 +01:00
2019-03-01 22:18:55 +01:00
config . rgtc_supported = config . extensions . has ( " GL_EXT_texture_compression_rgtc " ) | | config . extensions . has ( " GL_ARB_texture_compression_rgtc " ) | | config . extensions . has ( " EXT_texture_compression_rgtc " ) ;
2019-10-27 00:28:54 +02:00
config . bptc_supported = config . extensions . has ( " GL_ARB_texture_compression_bptc " ) | | config . extensions . has ( " EXT_texture_compression_bptc " ) ;
2019-03-01 22:18:55 +01:00
2019-03-01 15:20:44 +01:00
//determine formats for depth textures (or renderbuffers)
if ( config . support_depth_texture ) {
// Will use texture for depth
// have to manually see if we can create a valid framebuffer texture using UNSIGNED_INT,
// as there is no extension to test for this.
GLuint fbo ;
glGenFramebuffers ( 1 , & fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , fbo ) ;
GLuint depth ;
glGenTextures ( 1 , & depth ) ;
glBindTexture ( GL_TEXTURE_2D , depth ) ;
2019-11-23 19:22:39 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , config . depth_internalformat , 32 , 32 , 0 , GL_DEPTH_COMPONENT , config . depth_type , NULL ) ;
2019-03-01 15:20:44 +01:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_TEXTURE_2D , depth , 0 ) ;
GLenum status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
2019-08-10 08:12:58 +02:00
glBindFramebuffer ( GL_FRAMEBUFFER , system_fbo ) ;
glDeleteFramebuffers ( 1 , & fbo ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glDeleteTextures ( 1 , & depth ) ;
2019-11-03 05:58:30 +01:00
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
2019-08-10 08:12:58 +02:00
// If it fails, test to see if it supports a framebuffer texture using UNSIGNED_SHORT
// This is needed because many OSX devices don't support either UNSIGNED_INT or UNSIGNED_SHORT
2019-11-24 03:08:19 +01:00
# ifdef GLES_OVER_GL
2019-03-01 15:20:44 +01:00
config . depth_internalformat = GL_DEPTH_COMPONENT16 ;
2019-11-24 03:08:19 +01:00
# else
// OES_depth_texture extension only specifies GL_DEPTH_COMPONENT.
config . depth_internalformat = GL_DEPTH_COMPONENT ;
# endif
2019-03-01 15:20:44 +01:00
config . depth_type = GL_UNSIGNED_SHORT ;
2019-08-10 08:12:58 +02:00
glGenFramebuffers ( 1 , & fbo ) ;
glBindFramebuffer ( GL_FRAMEBUFFER , fbo ) ;
2019-03-01 15:20:44 +01:00
2019-08-10 08:12:58 +02:00
glGenTextures ( 1 , & depth ) ;
glBindTexture ( GL_TEXTURE_2D , depth ) ;
2019-11-24 03:08:19 +01:00
glTexImage2D ( GL_TEXTURE_2D , 0 , config . depth_internalformat , 32 , 32 , 0 , GL_DEPTH_COMPONENT , GL_UNSIGNED_SHORT , NULL ) ;
2019-08-10 08:12:58 +02:00
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameteri ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glFramebufferTexture2D ( GL_FRAMEBUFFER , GL_DEPTH_ATTACHMENT , GL_TEXTURE_2D , depth , 0 ) ;
status = glCheckFramebufferStatus ( GL_FRAMEBUFFER ) ;
if ( status ! = GL_FRAMEBUFFER_COMPLETE ) {
//if it fails again depth textures aren't supported, use rgba shadows and renderbuffer for depth
config . support_depth_texture = false ;
config . use_rgba_3d_shadows = true ;
}
glBindFramebuffer ( GL_FRAMEBUFFER , system_fbo ) ;
glDeleteFramebuffers ( 1 , & fbo ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glDeleteTextures ( 1 , & depth ) ;
}
2019-03-01 15:20:44 +01:00
}
//picky requirements for these
config . support_shadow_cubemaps = config . support_depth_texture & & config . support_write_depth & & config . support_depth_cubemaps ;
2017-12-04 13:41:34 +01:00
frame . count = 0 ;
frame . delta = 0 ;
frame . current_rt = NULL ;
frame . clear_request = false ;
2019-09-20 10:45:51 +02:00
glGetIntegerv ( GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS , & config . max_vertex_texture_image_units ) ;
2018-08-06 18:26:17 +02:00
glGetIntegerv ( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS , & config . max_texture_image_units ) ;
2017-12-04 13:41:34 +01:00
glGetIntegerv ( GL_MAX_TEXTURE_SIZE , & config . max_texture_size ) ;
2019-09-20 10:45:51 +02:00
// the use skeleton software path should be used if either float texture is not supported,
// OR max_vertex_texture_image_units is zero
config . use_skeleton_software = ( config . float_texture_supported = = false ) | | ( config . max_vertex_texture_image_units = = 0 ) ;
2017-12-04 13:41:34 +01:00
shaders . copy . init ( ) ;
2018-02-24 14:48:22 +01:00
shaders . cubemap_filter . init ( ) ;
2019-02-26 01:46:24 +01:00
bool ggx_hq = GLOBAL_GET ( " rendering/quality/reflections/high_quality_ggx " ) ;
2018-12-18 16:51:29 +01:00
shaders . cubemap_filter . set_conditional ( CubemapFilterShaderGLES2 : : LOW_QUALITY , ! ggx_hq ) ;
2018-02-24 14:48:22 +01:00
{
// quad for copying stuff
glGenBuffers ( 1 , & resources . quadie ) ;
glBindBuffer ( GL_ARRAY_BUFFER , resources . quadie ) ;
{
const float qv [ 16 ] = {
- 1 ,
- 1 ,
0 ,
0 ,
- 1 ,
1 ,
0 ,
1 ,
1 ,
1 ,
1 ,
1 ,
1 ,
- 1 ,
1 ,
0 ,
} ;
glBufferData ( GL_ARRAY_BUFFER , sizeof ( float ) * 16 , qv , GL_STATIC_DRAW ) ;
}
glBindBuffer ( GL_ARRAY_BUFFER , 0 ) ;
}
2017-12-04 13:41:34 +01:00
{
//default textures
glGenTextures ( 1 , & resources . white_tex ) ;
unsigned char whitetexdata [ 8 * 8 * 3 ] ;
for ( int i = 0 ; i < 8 * 8 * 3 ; i + + ) {
whitetexdata [ i ] = 255 ;
}
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . white_tex ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , 8 , 8 , 0 , GL_RGB , GL_UNSIGNED_BYTE , whitetexdata ) ;
glGenerateMipmap ( GL_TEXTURE_2D ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glGenTextures ( 1 , & resources . black_tex ) ;
unsigned char blacktexdata [ 8 * 8 * 3 ] ;
for ( int i = 0 ; i < 8 * 8 * 3 ; i + + ) {
blacktexdata [ i ] = 0 ;
}
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . black_tex ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , 8 , 8 , 0 , GL_RGB , GL_UNSIGNED_BYTE , blacktexdata ) ;
glGenerateMipmap ( GL_TEXTURE_2D ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glGenTextures ( 1 , & resources . normal_tex ) ;
unsigned char normaltexdata [ 8 * 8 * 3 ] ;
for ( int i = 0 ; i < 8 * 8 * 3 ; i + = 3 ) {
normaltexdata [ i + 0 ] = 128 ;
normaltexdata [ i + 1 ] = 128 ;
normaltexdata [ i + 2 ] = 255 ;
}
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . normal_tex ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , 8 , 8 , 0 , GL_RGB , GL_UNSIGNED_BYTE , normaltexdata ) ;
glGenerateMipmap ( GL_TEXTURE_2D ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glGenTextures ( 1 , & resources . aniso_tex ) ;
unsigned char anisotexdata [ 8 * 8 * 3 ] ;
for ( int i = 0 ; i < 8 * 8 * 3 ; i + = 3 ) {
anisotexdata [ i + 0 ] = 255 ;
anisotexdata [ i + 1 ] = 128 ;
anisotexdata [ i + 2 ] = 0 ;
}
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . aniso_tex ) ;
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_RGB , 8 , 8 , 0 , GL_RGB , GL_UNSIGNED_BYTE , anisotexdata ) ;
glGenerateMipmap ( GL_TEXTURE_2D ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
}
2018-02-24 14:48:22 +01:00
// skeleton buffer
{
resources . skeleton_transform_buffer_size = 0 ;
glGenBuffers ( 1 , & resources . skeleton_transform_buffer ) ;
}
// radical inverse vdc cache texture
// used for cubemap filtering
2018-09-30 04:47:24 +02:00
if ( true /*||config.float_texture_supported*/ ) { //uint8 is similar and works everywhere
2018-02-24 14:48:22 +01:00
glGenTextures ( 1 , & resources . radical_inverse_vdc_cache_tex ) ;
glActiveTexture ( GL_TEXTURE0 ) ;
glBindTexture ( GL_TEXTURE_2D , resources . radical_inverse_vdc_cache_tex ) ;
2018-09-30 04:47:24 +02:00
uint8_t radical_inverse [ 512 ] ;
2018-02-24 14:48:22 +01:00
for ( uint32_t i = 0 ; i < 512 ; i + + ) {
uint32_t bits = i ;
bits = ( bits < < 16 ) | ( bits > > 16 ) ;
bits = ( ( bits & 0x55555555 ) < < 1 ) | ( ( bits & 0xAAAAAAAA ) > > 1 ) ;
bits = ( ( bits & 0x33333333 ) < < 2 ) | ( ( bits & 0xCCCCCCCC ) > > 2 ) ;
bits = ( ( bits & 0x0F0F0F0F ) < < 4 ) | ( ( bits & 0xF0F0F0F0 ) > > 4 ) ;
bits = ( ( bits & 0x00FF00FF ) < < 8 ) | ( ( bits & 0xFF00FF00 ) > > 8 ) ;
float value = float ( bits ) * 2.3283064365386963e-10 ;
2018-09-30 04:47:24 +02:00
radical_inverse [ i ] = uint8_t ( CLAMP ( value * 255.0 , 0 , 255 ) ) ;
2018-02-24 14:48:22 +01:00
}
2018-09-30 04:47:24 +02:00
glTexImage2D ( GL_TEXTURE_2D , 0 , GL_LUMINANCE , 512 , 1 , 0 , GL_LUMINANCE , GL_UNSIGNED_BYTE , radical_inverse ) ;
2019-02-26 01:46:24 +01:00
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_CLAMP_TO_EDGE ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_NEAREST ) ;
glTexParameterf ( GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_NEAREST ) ; //need this for proper sampling
2018-02-24 14:48:22 +01:00
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
}
2018-09-23 17:12:30 +02:00
2019-02-26 01:46:24 +01:00
{
glGenFramebuffers ( 1 , & resources . mipmap_blur_fbo ) ;
glGenTextures ( 1 , & resources . mipmap_blur_color ) ;
}
2018-09-23 17:12:30 +02:00
# ifdef GLES_OVER_GL
2018-09-25 15:36:26 +02:00
//this needs to be enabled manually in OpenGL 2.1
2019-03-11 20:48:26 +01:00
if ( config . extensions . has ( " GL_ARB_seamless_cube_map " ) ) {
glEnable ( _EXT_TEXTURE_CUBE_MAP_SEAMLESS ) ;
}
2018-09-25 15:36:26 +02:00
glEnable ( GL_POINT_SPRITE ) ;
glEnable ( GL_VERTEX_PROGRAM_POINT_SIZE ) ;
2018-09-23 17:12:30 +02:00
# endif
config . force_vertex_shading = GLOBAL_GET ( " rendering/quality/shading/force_vertex_shading " ) ;
2018-10-24 15:22:50 +02:00
config . use_fast_texture_filter = GLOBAL_GET ( " rendering/quality/filters/use_nearest_mipmap_filter " ) ;
2017-12-04 13:41:34 +01:00
}
void RasterizerStorageGLES2 : : finalize ( ) {
}
2018-02-24 14:48:22 +01:00
void RasterizerStorageGLES2 : : _copy_screen ( ) {
bind_quad_array ( ) ;
glDrawArrays ( GL_TRIANGLE_FAN , 0 , 4 ) ;
}
2017-12-04 13:41:34 +01:00
void RasterizerStorageGLES2 : : update_dirty_resources ( ) {
update_dirty_shaders ( ) ;
update_dirty_materials ( ) ;
2018-02-24 14:48:22 +01:00
update_dirty_skeletons ( ) ;
2018-09-29 18:49:34 +02:00
update_dirty_multimeshes ( ) ;
2017-12-04 13:41:34 +01:00
}
RasterizerStorageGLES2 : : RasterizerStorageGLES2 ( ) {
RasterizerStorageGLES2 : : system_fbo = 0 ;
}